Java笔记——包装类（自动拆装箱）

在Java中，我们常说"一切皆对象"，但基本类型（int、char、boolean等）却是个例外。为了让基本类型也能参与到面向对象的世界中，Java为每个基本类型设计了对应的包装类（Wrapper Class）。而JDK 5引入的自动装箱（Autoboxing）和自动拆箱（Unboxing）机制，进一步模糊了基本类型与包装类之间的界限，让代码更简洁。然而，这种"自动"背后隐藏着许多细节和陷阱，本文带你全面了解包装类及其自动转换机制。

一、为什么要用包装类？

基本类型有它的优势：存储在栈上，效率高，占用内存小。但有些场景下，我们必须使用对象：

1. 集合框架 ：List、Set、Map等只能存储对象，不能存储基本类型。所以需要用包装类将int包装成Integer。

2. 泛型 ：泛型参数不能是基本类型，必须是引用类型。例如List<Integer>合法，List<int>不合法。

3. 对象方法调用 ：包装类提供了许多实用方法，如Integer.parseInt()、Double.isNaN()等。

4. 空值表达 ：基本类型不能为null，而包装类可以，这在某些场景（如数据库字段可能为NULL）非常有用。

二、基本类型对应的包装类

基本类型	包装类	父类	示例
byte	Byte	Number	Byte b = 1;
short	Short	Number	Short s = 1;
int	Integer	Number	Integer i = 1;
long	Long	Number	Long l = 1L;
float	Float	Number	Float f = 1.0f;
double	Double	Number	Double d = 1.0;
char	Character	Object	Character c = 'a';
boolean	Boolean	Object	Boolean b = true;

除了Character和Boolean，其他数值型包装类都继承自Number抽象类。

三、自动装箱与拆箱

3.1 自动装箱（Autoboxing）

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

// 手动装箱
Integer i1 = Integer.valueOf(10);

// 自动装箱
Integer i2 = 10;  // 编译器自动转换为 Integer.valueOf(10)

3.2 自动拆箱（Unboxing）

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

// 手动拆箱
int n1 = i1.intValue();

// 自动拆箱
int n2 = i2;  // 编译器自动转换为 i2.intValue()

3.3 发生的场景

自动装箱与拆箱在以下场景中自动发生：

• 赋值 ：如Integer i = 5;、int n = i;

• 方法调用：传递基本类型给期望包装类的方法，或反之。

• 算术运算 ：包装类参与+、-、*、/等运算时会自动拆箱。

• 比较运算 ：==、!=、<、>等比较时，如果一方是基本类型，另一方是包装类，会触发拆箱。

Integer a = 100;
Integer b = 200;
int sum = a + b;   // a和b先拆箱为int，再相加，结果自动装箱? 不，sum是int，所以不需要装箱

四、背后的字节码：编译器做了什么？

我们可以通过javap -c查看字节码，看看自动装箱拆箱到底发生了什么。

源代码：

public class AutoBoxing {
    public static void main(String[] args) {
        Integer i = 10;
        int n = i;
    }
}

字节码关键部分：

0: bipush        10
2: invokestatic  #2   // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: astore_1
6: aload_1
7: invokevirtual #3   // Method java/lang/Integer.intValue:()I
10: istore_2

可见，Integer i = 10;被编译为Integer.valueOf(10)，而int n = i;被编译为i.intValue()。

五、深入细节：缓存与陷阱

5.1 缓存池（IntegerCache）

为了提高性能和节约内存，Java对部分包装类实现了缓存机制。最典型的是Integer，它在-128到127之间的值会被缓存，复用同一个对象。

Integer a = 100;
Integer b = 100;
System.out.println(a == b);  // true，因为引用同一个缓存对象

Integer c = 200;
Integer d = 200;
System.out.println(c == d);  // false，超出缓存范围，各自new Integer

注意 ：==比较的是对象引用，而不是数值。如果要比较数值，请使用equals()方法。

其他包装类也有类似的缓存：

• Byte、Short、Long：缓存-128~127

• Character：缓存0~127

• Boolean：缓存true和false两个实例

5.2 空指针异常（NullPointerException）

自动拆箱时，如果包装类对象为null，会抛出NPE。

Integer i = null;
int n = i;   // 编译通过，但运行时抛出 NullPointerException

常见陷阱：

Integer count = getCountFromDB(); // 可能返回null
int total = count + 1;            // 若count为null，NPE

解决方案：使用Optional或提前判空。

5.3 性能问题

自动装箱和拆箱会创建额外的对象，尤其在循环中大量使用时，会影响性能。

Integer sum = 0;
for (int i = 0; i < 1000000; i++) {
    sum += i;   // 每次循环：i自动装箱，sum自动拆箱，加法，结果自动装箱
}

上述代码会创建大量临时Integer对象，效率低下。应改为：

int sum = 0;
for (int i = 0; i < 1000000; i++) {
    sum += i;
}
// 最后如果需要Integer，再手动装箱一次

5.4 重载与装箱

方法重载时，编译器会选择最匹配的方法，装箱拆箱可能导致意想不到的选择。

public class OverloadTest {
    public static void print(int i) { System.out.println("int"); }
    public static void print(Integer i) { System.out.println("Integer"); }
    
    public static void main(String[] args) {
        print(10);     // 输出 "int"
        print(10L);    // 输出 "Integer"? 不，10L是long，匹配不到int或Integer，会先尝试自动转换？
        // 实际上编译错误，因为long不能自动转换为int或Integer，需要手动强转或提供long重载
    }
}

更常见的是，当包装类和基本类型同时存在时，调用带有包装类参数的方法时，传入基本类型会触发装箱，反之亦然。

六、最佳实践

1. 基本类型优先：在没有对象需求时，尽量使用基本类型，避免不必要的装箱。

2. 警惕null ：当使用包装类时，始终考虑其为null的可能性，尤其在拆箱前做非空判断。

3. 数值比较用equals ：包装类对象比较数值时，务必使用equals()方法，而不是==。

4. 注意缓存范围 ：理解Integer缓存机制，避免因==比较超出缓存范围的值而犯错。

5. 集合中尽量使用基本类型的包装类：这是必须的，但要注意自动拆箱时的性能开销。

6. 使用Optional包装可能为null的包装类 ：Java 8引入的Optional可以帮助优雅处理可能为null的值。

七、总结

特性	基本类型	包装类
存储位置	栈（或局部变量表）	堆（对象）
默认值	0/false等具体值	null
性能	高，无对象开销	较低，有对象创建和回收
支持null	否	是
泛型支持	否	是
集合存储	否	是

自动装箱和拆箱是Java为我们提供的语法糖，让代码更简洁，但使用时必须了解其背后的机制和潜在陷阱。正确使用包装类和自动转换，可以写出既优雅又健壮的代码。