1 什么是包装类 🚀

🔥 在 JAVA 中，八大基础数据类型（int,float,double...）不是继承自 Object，并且不具备对象的特征的。比如：基本数据类型就不能调用方法。

int i = 10;
i.toString();

使用这段代码就会出错。

🍊 但是我们在开发过程中肯定会遇到，将基本数据类型转换为String类型，或者其他数据类型，而这个时候如果我们要用基础数据类型实现这些转换就会非常麻烦，所以Java就有了基本数据类型的包装类，顾名思义，包装类就是：将基本数据类型包装成对象，使其具有了对象的属性和方法。
这样就可以使用方法和属性了。

而包装类的主要作用也就是：

• 将本类型与其他类型进行转换；
• 将字符串与本类型及包装类型相互转换。

因此为了在泛型代码中可以支持基本类型，并且让基本数据类型也具备对象的特征，Java 给每个基本类型都对应 一个包装类型

2. 怎么使用包装类❓

首先我们来看如何定义包装类：比如定义一个int类型的包装类

• 定义整形包装类

Integer i1 = new Integer(100);  //定义一个值为100的 整形包装类
Integer i2 = 100

我们可能会有疑问，数据变成了包装类，之后要使用数据怎么办呢 --> 很简单，我们在将包装类转换成基本数据类型就可以了

• 包装类转换成基本数据类型

Integer i1 = new Integer(100);
int value = i1;//方法1
int value2 = i1.intValue();//方法2

经过上述步骤就可以将包装类转换成基本数据类型了，这两个例子分别展示了如何将int类型转换成包装类，如何将包装类转换成int类型。

 

3. 包装类与基本类型的转换 🔍

• 我们一般将“基本数据类型转换成包装类”的过程叫做装箱，将“包装类转换成基本数据类型”的过程叫做拆箱

• 当包装类与基本数据类型比较，会自动将包装类拆箱为基本数据类型
  java1.5之后又自动装箱（autoboxing）和自动拆箱（autounboxing）功能

3.1 装箱

1. 把基本数据类型转为包装类对象。
2. 可以分为手动装箱和自动装箱：
3. 是为了使用专门为对象设计的API和特性

下面以 int 类型为例：

int i = 10; // 定义一个 int 基本类型值
Integer x = new Integer(i); //手动装箱
Integer y = i; // 自动装箱

 

3.2 拆箱

1. 把包装类对象拆为基本数据类型
2. 可以分为手动拆箱和自动拆箱
3. 一般是因为需要运算，Java中的大多数运算符是为基本数据类型设计的。比较、算术等

下面以 int 类型为例：

Integer j = new Integer(8); // 定义一个 Integer 包装类对象，值为8
int m = j.intValue(); // 手动拆箱 int 类型
int n = j; // 自动拆箱为 int 类型

注： 由于我们经常要做基本类型与包装类之间的转换，从JDK5.0 开始，基本类型与包装类的装箱、拆箱动作可以自动完成

• 注意：只能与自己对应的类型之间才能实现自动装箱与拆箱

 

4. 基本数据类型、包装类与字符串间的转换 📚

（1）包装类转换成其他基本数据类型

Integer i = new Integer(100);

//转换成double类型
double d = i.doubleValue();

//转换成float类型
float f = i.floatValue();

（2）基本数据类型转为字符串

 

1. 使用包装类的toString()方法；
2. 使用String类的valueOf()方法；
3. 使用一个空字符串加上基本类型。

int a = 10;
// 方法1
String s3 = Integer.toString(a);
// 方法2
String s1 = String.valueOf(a);
// 方法3
String s2 = a + "";

（3）字符串转为基本数据类型

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

• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。

String a="123";
Integer.parseInt(a);
Short.parseShort(a);
Byte.parseByte(a);
Long.parseLong(a);
Float.parseFloat(a);
Double.parseDouble(a);
Boolean.parseBoolean(a);

🍉 方式2：字符串转为包装类，然后可以自动拆箱为基本数据类型

• public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类，然后可以自动拆箱为int基本类型
• public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类，然后可以自动拆箱为long基本类型
• public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类，然后可以自动拆箱为double基本类型

 

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

5. 包装类对象的特点 💘

包装类	缓存对象
Byte	-128  - 127
Short	-128 - 127
Integer	-128 - 127
Long	-128 - 127
Float	没有
Double	没有
Character	0 - 127
Boolean	true 和 false

（1）Integer128 问题

public static void main(String[] args) {
    Integer a = 127;
    Integer b = 127;
    Integer c = 128;
    Integer d = 128;
    int e = 128;
    System.out.println(a == b); // true
    System.out.println(c == d); // false
    System.out.println(d == e); // true
}

• 其中在判断(c == d)时输出了false，很明显输出结果并不符合预期，在逻辑上也并不正确，而同样的128==128的比较在基本数据类型int下便可以正常输出true，首先要先弄清在128赋值时发生了什么，接下来通过javap -c反编译查看测试代码的字节码。

🍎 提醒一下：使用equals比较时，无论赋什么值都可以正确输出true，下文所有讨论都建立在使用==比较的前提上，同时出现问题的另一个本质也可以说是因为==比较的是地址。

在反编译结果，可以知道Integer在初始化时调用了Integer.valueOf()方法，这也就是我们上面所讲的Java的自动装箱机制.。

在Integer对象创建过程中：

• 如果传入value数值在-128~127范围内，那么所有在这个范围内被创建的对象（句柄）实际都指向同一个地址，即被预创建Integer对象所在的地址。
• 如果传入value数值不在范围内，那么每次被创建的对象（句柄）都指向一个新的且不同的地址，即通过new关键字由JVM分配的新地址。

（2）Integer 和 new Integer 问题

案例：

// 情况一：
public static void main(String[] args) {
    Integer m = new Integer(1);//新new的在堆中
    Integer n = 1;//这个用的是缓冲的常量对象，在方法区
    System.out.println(m == n);//false

    Integer x = new Integer(1);//新new的在堆中
    Integer y = new Integer(1);//另一个新new的在堆中
    System.out.println(x == y);//fa
}


// 情况二：
public static void main(String[] args) {
    int a = 10;
    String b = "10";

    Integer a1 = a;
    Integer b1 = Integer.parseInt(b);
    System.out.println(a1 == b1); // true

    Integer a2 = new Integer(a);
    Integer b2 = new Integer(b);
    System.out.println(a2 == b2); // false
}

Integer n = 1;

• Integer变量指向的是 java 常量池中的对象

new Integer(1);

• new Integer() 的变量指向堆中新建的对象,两者在内存中的地址不同。

（3）类型转换问题

public static void main(String[] args) {
    Integer i1 = 10;
    double i2 = 10;
    // 会将i 自动拆箱为 int，然后根据基本数据类型 ”自动类型转换"规则，转为 double 比较
    System.out.println(i1 == i2); // true 

    int i3 = 10;
    // 会自动拆箱，按照基本数据类型进行比较
    System.out.println(i1 == i3); // true
    
    Integer i4 = new Integer(10);  
    System.out.println(i3 == i4); // true
    System.out.println(i1 == i4); // false
    
    Double i5 = 10.0;
    System.out.println(i1 == i5); //编译报错
}

int 变量与 Integer、 int 变量与new Integer() 比较时，只要两个的值是相等，则为true因为包装类Integer 和 基本数据类型int 比较时，java会自动拆包装为int ，然后进行比较，实际上就变为两个int变量的比较。

 

🥑 脚下留心：使用包装类时候的注意事项

使用包装类时，需要注意以下几点：

1. 包装类都重写了Object 类中的toString()方法，以字符串的形式返回被包装的基本数据类型的值。
2. 除了Character外，包装类都有valueOf(String s)方法，可以根据String类型的参数S创建包装类对象，但参数s不能为null，而且该字符串必须是可以解析为相应基本类型的数据，否则虽然可以编译通过，但运行时会报错。具体示例如下：

   Integer i = Integer.valueof("123");
   //合法
   Integer i = Integer,valueof("12a");
   //不合法，“12a“不能被正确解析为基本数据类型

3. 除了Character 外，包装类都有parseXxx(String s）静态方法，该方法的作用是将字符串转换为对应的基本类型的数据。参数不能为null，而且该字符串必须可以解析为相应基本类型的数据，否则虽然可以编译通过，但运行时会报错。具体示例如下:

int i= Integer.parseInt("123");
//合法
Integer in= Integer.parseInt("itcast");
1/不合法 

 

---

6. 小结 📖

包装类的特点：

1. 对象化: 包装类使基本数据类型可以作为对象处理，允许与 Java 的集合框架配合使用。
2. 不可变性: 包装类对象是不可变的，即一旦创建，其值不能更改。
3. 类型转换: 包装类可以自动进行基本类型与对象之间的转换（自动装箱和拆箱）。
   • 自动装箱：将基本数据类型自动转换为对应的包装类。
   • 拆箱：将包装类对象自动转换为对应的基本数据类型。

包装类是 Java 中一个重要的特性，它使得基本数据类型能够以对象的形式进行处理，增强了语言的灵活性与功能性。通过了解包装类的特点和使用场景，可以在 Java 编程中更有效地处理数据。