本文讲解Java的装箱与拆箱：基本类型与其包装类之间的自动转换。它简化了代码，但也可能引发NullPointerException、性能问题和对象比较混乱。应优先使用.equals()比较包装类对象。

我们来详细讲解一下 Java 中的装箱（Boxing）和拆箱（Unboxing），这是 Java 语言的一个重要特性。

1. 核心概念

在 Java 中，数据类型分为两大类：

• 基本数据类型 (Primitive Types): 如 int, double, char, boolean, long, short, byte, float。它们不是对象，只是纯粹的数值，存储在栈内存中，效率高。
• 引用类型 (Reference Types): 如类（Class）、接口（Interface）、数组（Array）等。它们是对象，实例存储在堆内存中，变量本身（引用）存储在栈内存中。

问题来了：有时候我们需要将基本数据类型当作对象来处理，比如将它们放入只能存储对象的集合（如 ArrayList, HashMap）中。为了解决这个问题，Java为每个基本数据类型都提供了一个对应的包装类 (Wrapper Class)。

现在，我们可以定义装箱和拆箱了：

• 装箱 (Boxing): 将一个基本数据类型的值，转换成其对应包装类的对象。

  • 例如：将 int 类型的 10 转换成 Integer 对象。

• 拆箱 (Unboxing): 将一个包装类的对象，转换成其对应的基本数据类型的值。

  • 例如：将 Integer 对象转换回 int 类型的 10。

2. 自动装箱与自动拆箱 (Autoboxing / Auto-unboxing)

在 JDK 1.5 之前，装箱和拆箱操作需要手动完成，代码比较繁琐。

手动装箱/拆箱 (JDK 1.5 之前):

// 手动装箱
int primitiveInt = 10;
Integer wrapperInt = Integer.valueOf(primitiveInt); // 或者 new Integer(primitiveInt)

// 手动拆箱
int anotherPrimitiveInt = wrapperInt.intValue();

从 JDK 1.5 开始，Java 引入了自动装箱和自动拆箱的特性，这让代码变得更加简洁。编译器会在编译时自动为我们插入相应的转换代码。

自动装箱/拆箱 (JDK 1.5 及以后):

// 自动装箱：编译器会自动转换为 Integer.valueOf(100)
Integer autoWrapperInt = 100;

// 自动拆箱：编译器会自动转换为 autoWrapperInt.intValue()
int autoPrimitiveInt = autoWrapperInt;

自动装箱/拆箱发生的常见场景：

1. 赋值操作
   java

   Integer i = 10;      // 自动装箱
   int j = i;           // 自动拆箱

2. 方法调用
   java

   public void printInteger(Integer num) {
       System.out.println(num);
   }
   
   // 调用时，基本类型 5 会被自动装箱为 Integer 对象
   printInteger(5);

3. 集合操作
   java

   List<Integer> list = new ArrayList<>();
   // 自动装箱：将 int 10 转换为 Integer 对象再添加到 list 中
   list.add(10);
   
   // 自动拆箱：从 list 中取出 Integer 对象，并赋值给 int 变量
   int value = list.get(0);

4. 算术运算
   java

   Integer a = 10;
   Integer b = 20;
   
   // a 和 b 会先自动拆箱为 int，进行加法运算，
   // 然后结果 30 再自动装箱为 Integer 赋给 c
   Integer c = a + b;
   
   Integer d = 1;
   d++; // 先拆箱，再自增，再装箱
   System.out.println(d); // 输出 2

3. 需要注意的陷阱和最佳实践

虽然自动装箱/拆箱很方便，但如果不了解其背后原理，可能会遇到一些问题。

陷阱 1：NullPointerException

这是最常见的陷阱。因为包装类是对象，所以它可以是 null。当一个为 null 的包装类对象进行自动拆箱时，会抛出 NullPointerException。

public int getLuckyNumber() {
    // 假设因为某种原因，这里返回了 null
    return null;
}

// 错误示例
Integer luckyNumber = null;
int number = luckyNumber; // 运行时会抛出 NullPointerException
                          // 因为这行代码等价于 luckyNumber.intValue()
                          // 在一个 null 对象上调用方法，自然会报错

最佳实践：在进行拆箱操作前，最好先进行非空检查。

陷阱 2：性能问题

自动装箱/拆箱会创建额外的对象，这会带来一些性能开销，尤其是在循环中。

// 不推荐的写法
Long sum = 0L; // L表示这是一个Long类型的字面量
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i; // 每次循环都会发生：拆箱(sum) -> 加法 -> 装箱(新sum)
}

在上面的循环中，sum += i 实际上会执行以下步骤：

1. sum.longValue(): 自动拆箱。
2. longValue() + i: 执行加法。
3. Long.valueOf(...): 自动装箱，创建一个新的 Long 对象并赋给 sum。

这意味着循环中会创建大量不必要的 Long 对象，增加了垃圾回收（GC）的压力，严重影响性能。

最佳实践：在需要进行大量计算的场景，特别是循环中，应优先使用基本数据类型。

// 推荐的写法
long sum = 0L; // 使用基本数据类型
for (long i = 0; i < Integer.MAX_VALUE; i++) {
    sum += i; // 这里只有基本数据类型的运算，非常高效
}

陷阱 3：对象比较 (== vs .equals())

== 运算符在用于对象时，比较的是内存地址；而 .equals() 方法（如果被正确重写）比较的是对象的内容（值）。

对于包装类，== 的行为可能会让人困惑。Java 为了提高性能，对一部分包装类对象进行了缓存。

• Integer 缓存：默认情况下，对于 -128 到 127 之间的整数，通过自动装箱（或 Integer.valueOf()）创建的 Integer 对象会被缓存。如果值在这个范围内，你会得到指向同一个缓存对象的引用。

示例：

Integer a = 100;
Integer b = 100;
System.out.println(a == b); // true, 因为 100 在缓存范围内，a 和 b 指向同一个对象

Integer c = 200;
Integer d = 200;
System.out.println(c == d); // false, 因为 200 超出缓存范围，c 和 d 是两个不同的新对象

Integer e = new Integer(100); // 使用 new 关键字会强制创建新对象
Integer f = new Integer(100);
System.out.println(e == f); // false, new 总是创建新对象

// 正确的比较方式
System.out.println(c.equals(d)); // true, equals() 比较的是值

最佳实践：任何时候，比较两个包装类对象的值，都应该使用 .equals() 方法，而不是 ==。

总结

何时使用基本类型 vs 包装类？

1. 优先使用基本类型：如果只是进行数值计算，并且不需要对象特性（如泛型、null 值），那么应该优先使用基本类型，因为它们性能更高，更节省内存。

2. 使用包装类：

   • 当需要将数据存入泛型集合（如 List<Integer>）时。
   • 当一个字段或方法返回值需要表示“未设置”或“无效”的状态时，可以使用 null。
   • 当需要调用包装类提供的一些有用方法时（如 Integer.parseInt()）。