20.包装类

包装类

1. 包装类概述

Java包装类是一组提供与基本数据类型（如 int、double、boolean 等）对应的对象形式的类。它们位于java.lang包中，提供了将基本数据类型转换为对象的功能。

Java的包装类主要有以下几个方面的作用和用途：

1. 将基本数据类型封装为对象

   Java的包装类允许将基本数据类型转换为对象，这样可以使用对象的特性和功能来处理基本数据类型。例如，可以使用Integer类来操作整数。

2. 提供与基本数据类型之间的转换

   包装类提供了方法来实现基本数据类型和包装类之间的相互转换。通过这些方法，可以将基本数据类型转换为包装类对象，以及将包装类对象转换为基本数据类型。

3. 支持与其他类的集成

   由于包装类是对象，因此可以在Java中使用它们进行类之间的继承和实现，从而支持类的集成和多态性。

4. 提供与基本数据类型相关的常量和方法

   包装类还定义了与基本数据类型相关的一些常量和方法。例如，Integer类提供了表示整数最大值和最小值的常量，以及执行整数操作的方法，如比较、转换等。

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类。

如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

2. Integer类

• Integer类概述

Integer类是Java中的一个包装类，位于java.lang包中。它提供了对基本数据类型int的封装，将原始的int类型数据转换为Integer对象。

Integer类具有以下特点和功能：

1. 封装与基本数据类型int的转换：Integer类允许将int类型的数据转换为Integer对象，以便在需要对象形式的数据时使用。可以使用Integer的构造方法或者valueOf()方法将int值封装为Integer对象。

2. 支持数值操作和比较：Integer类提供了各种方法来进行数值操作，例如加法、减法、乘法和除法等。此外，它还提供了比较方法，如equals()用于比较两个Integer对象是否相等。

3. 支持基本数据类型与字符串之间的转换：Integer类提供了将Integer对象转换为字符串的方法toString()，以及将字符串转换为Integer对象的静态方法parseInt()。这些方法方便了基本数据类型int与字符串之间的相互转换。

4. 提供了表示最大值和最小值的常量：Integer类定义了常量Integer.MAX_VALUE和Integer.MIN_VALUE，分别表示int类型的最大值和最小值。

5. 支持自动装箱和拆箱：Java 5及以上的版本支持自动装箱（Autoboxing）和拆箱（Unboxing），也即在需要基本数据类型int时，可以直接使用Integer对象，并在需要Integer对象时，可以将其转换为int类型。

• Integer类构造方法及静态方法

方法名	说明
public Integer(int value)	根据 int 值创建 Integer 对象(过时)
public Integer(String s)	根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i)	返回表示指定的 int 值的 Integer 实例
public static Integer valueOf(String s)	返回保存指定String值的 Integer 对象
static string tobinarystring(int i)	得到二进制
static string tooctalstring(int i)	得到八进制
static string toHexstring(int i)	得到十六进制
static int parseInt(string s)	将字符串类型的整数转成int类型的整数

两种获取对象的区别：

因为在实际开发中，-128~127之间的数据用的比较多，如果每次使用都是new对象的，那么太浪费内存了。

所以，提前把这个范围内的每一个数据都创建好对象，并存入数组中，如果用到了不会创建新的，而是返回已经创建好的对象。

• 示例代码

//public Integer(int value)：根据 int 值创建 Integer 对象(过时)
Integer i1 = new Integer(100);
System.out.println(i1);

//public Integer(String s)：根据 String 值创建 Integer 对象(过时)
Integer i2 = new Integer("100");
//Integer i2 = new Integer("abc"); //NumberFormatException
System.out.println(i2);
System.out.println("--------");

//public static Integer valueOf(int i)：返回表示指定的 int 值的 Integer 实例
Integer i3 = Integer.valueOf(100);
System.out.println(i3);

//public static Integer valueOf(String s)：返回保存指定String值的Integer对象 
Integer i4 = Integer.valueOf("100");
System.out.println(i4);

package text;

/*
  public static string tobinarystring(int i)            得到二进制
  public static string tooctalstring(int i)             得到八进制
  public static string toHexstring(int i)               得到十六进制
  public static int parseInt(string s)                  将字符串类型的整数转成int类型的整数
 */
public class text99 {
    public static void main(String[] args) {
        //得到二进制
        String str1 = Integer.toBinaryString(100);
        System.out.println(str1);         //1100100

        //得到八进制
        String str2 = Integer.toOctalString(100);
        System.out.println(str2);         //144

        //得到十六进制
        String str3 = Integer.toHexString(100);
        System.out.println(str3);        //64

        //将字符串类型的整数转成int类型的整数
        //强类型语言：每种语言在java中都有各自的数据类型
        //在计算的时候，如果不是同一种数据类型，是无法直接计算的
        int i = Integer.parseInt("123");
        System.out.println(i);         //123
        System.out.println(i + 1);       //124
        //在类型转换的时候，括号中的参数只能是数字，不能是其他的，否则代码会报错
        //八种包装类当中，除了Character都有对应的parseXxx的方法，进行类型转换
        String str = "true";
        boolean b = Boolean.parseBoolean(str);
        System.out.println(b);       //true
    }
}

3. 装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

• 装箱：从基本类型转换为对应的包装类对象。

• 拆箱：从包装类对象转换为对应的基本类型。

用Integer与 int为例：

• 基本数值---->包装对象

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

• 包装对象---->基本数值

int num = i.intValue();

3.1 装箱

装箱是将基本数据类型转换为对应的包装类对象。在需要使用对象的场景中，可以使用自动装箱（Autoboxing）或显式装箱（Explicit Boxing）将基本数据类型封装为对应的包装类对象。例如，将int类型的值封装为Integer对象。

• 自动装箱

  自动装箱是指在编译器自动将基本数据类型转换为对应的包装类对象。

  例如，可以通过赋值操作将int类型的值直接赋给Integer变量：

  int num = 10;
  Integer obj = num;
  

• 显示装箱

  显式装箱是通过调用相应的构造方法或使用valueOf()方法将基本数据类型封装为包装类对象。

  例如，使用Integer的构造方法进行显式装箱：

  int num = 10;
  Integer obj = new Integer(num);
  

3.2 拆箱

拆箱是将包装类对象转换为对应的基本数据类型。在需要使用基本数据类型的场景中，可以使用自动拆箱（Autounboxing）或显式拆箱（Explicit Unboxing）将包装类对象转换为基本数据类型。例如，获取包装类对象中的值。

• 自动拆箱

  自动拆箱是指在编译器自动将包装类对象转换为对应的基本数据类型。

  例如，可以直接进行算术运算：

  Integer obj = 10;
  int num = obj;
  

• 显式拆箱

  显式拆箱是通过调用包装类对象的xxxValue()方法将其转换为对应的基本数据类型。

  例如，使用intValue()方法进行显式拆箱：

  Integer obj = new Integer(10);
  int num = obj.intValue();
  

3.3 注意事项

当使用装箱和拆箱时，需要注意以下几点：

1. 自动装箱和拆箱：自动装箱和拆箱是在Java 5及以上版本引入的特性，可以自动进行基本数据类型和包装类之间的转换。这使得代码更加简洁，不需要显式地进行装箱和拆箱操作。

2. 值的缓存：在装箱过程中，Java针对一些常用的数值进行了缓存，以提高性能和节省内存。例如，对于范围为-128到127之间的整数，Integer类会缓存这些数值的对象，当装箱时会直接返回缓存的对象，而不是重新创建。这个缓存特性可以通过Integer.valueOf()方法来使用。

3. 对象引用比较：使用包装类时需要注意对象引用的比较。对于包装类对象，应该使用equals()方法来进行比较，而不能使用== 操作符来判断。因为==操作符用于比较对象的引用，而不是比较对象的值。

4. NullPointerException：在拆箱过程中，如果尝试对一个为null的包装类对象进行拆箱操作，会抛出NullPointerException异常。因此，在拆箱之前应确保包装类对象不为null，可以通过null检查或使用Optional类来处理。

5. 性能考虑：装箱和拆箱操作涉及到对象的创建和销毁，对于频繁进行装箱和拆箱的场景，可能会对性能产生一定影响。在性能要求较高的情况下，可以考虑直接使用基本数据类型避免装箱和拆箱的开销。

4. 基本类型与字符串之间的转换

4.1 基本类型转换为String

• 转换方式

• 方式一：直接在数字后加一个空字符串

• 方式二：通过String类静态方法valueOf()

  示例代码：

  public class Integer {
      public static void main(String[] args) {
          //int --- String
      int number = 100;
      //方式1
      String s1 = number + "";
      System.out.println(s1);
      //方式2
      //public static String valueOf(int i)
      String s2 = String.valueOf(number);
      System.out.println(s2);
      System.out.println("--------");
  	}
  }
  

4.2 String转换成基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

• 转换方式

  • 方式一：先将字符串数字转成Integer，再调用valueOf()方法

  • 方式二：通过Integer静态方法parseInt()进行转换

• 示例代码

public class Integer {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

5. 底层原理

建议：获取Integer对象的时候不要自己new，而是采取直接赋值或者静态方法valueOf的方式

因为在实际开发中，-128~127之间的数据，用的比较多。如果每次使用都是new对象，那么太浪费内存了。

所以，提前把这个范围之内的每一个数据都创建好对象，如果要用到了不会创建新的，而是返回已经创建好的对象。

//1.利用构造方法获取Integer的对象(JDK5以前的方式)
		Integer i1 = new Integer(1);
        Integer i2 = new Integer("1");
        System.out.println(i1);
        System.out.println(i2);

//2.利用静态方法获取Integer的对象(JDK5以前的方式)
		Integer i3 = Integer.valueOf(123);
		Integer i4 = Integer.valueOf("123");
		Integer i5 = Integer.valueOf("123", 8);
		
		System.out.println(i3);
		System.out.println(i4);
		System.out.println(i5);

//3.这两种方式获取对象的区别(掌握)
//底层原理：
//因为在实际开发中，-128~127之间的数据，用的比较多。
//如果每次使用都是new对象，那么太浪费内存了
//所以，提前把这个范围之内的每一个数据都创建好对象
//如果要用到了不会创建新的，而是返回已经创建好的对象。
		Integer i6 = Integer.valueOf(127);
		Integer i7 = Integer.valueOf(127);
		System.out.println(i6 == i7);//true
		
		Integer i8 = Integer.valueOf(128);
		Integer i9 = Integer.valueOf(128);
		System.out.println(i8 == i9);//false

//因为看到了new关键字，在Java中，每一次new都是创建了一个新的对象
//所以下面的两个对象都是new出来，地址值不一样。
		Integer i10 = new Integer(127);
        Integer i11 = new Integer(127);
        System.out.println(i10 == i11);//false

        Integer i12 = new Integer(128);
        Integer i13 = new Integer(128);
        System.out.println(i12 == i13);//false