深入理解Java包装类：自动装箱拆箱与缓存池机制

深入理解Java包装类：自动装箱拆箱与缓存池机制

对象包装器

Java中的数据类型可以分为两类：基本类型和引用类型。作为一门面向对象编程语言， 一切皆对象是Java语言的设计理念之一。但基本类型不是对象，无法直接参与面向对象操作，为了解决这个问题，Java让每个基本类型都有一个与之对应的包装器类型。

Java中有8种不可变的基本类型，分别为：

• 整型：byte、short、int、long
• 浮点类型：float、double
• 字符类型：char
• 布尔类型：boolean

这八种基本类型都有对应的包装类分别为：Byte、Short、Integer、Long、Float、Double、Character、Boolean （前6个派生于公共的超类Number）。包装器类是不可变的，即一旦构造了包装器，就不允许更改包装在其中的值。同时，包装器类还是final，因此不能派生它们的子类。

Java不是“一切皆对象”吗，为什么还要保留基本数据类型？

包装类是引用类型，对象的引用存储在栈中，对象本身存储在堆中；而对于基本数据类型，变量对应的内存块直接存储数据本身（栈中）。因此，基本数据类型读写效率更高效。在64位JVM上，在开启引用压缩的情况下，一个Integer对象占用16个字节的内存空间，而一个int类型数据只占用4字节的内存空间，前者对空间的占用是后者的4倍。也就是说，不管是读写效率还是存储效率，基本类型都更高效。尽管Java强调面向对象，但为了性能做了妥协。

自动装箱与拆箱

装箱和拆箱是实现基本数据类型与包装类之间相互转换的特性。Java 5引入自动装箱/拆箱功能，进一步简化了包装类的使用。

• 装箱：将基本数据类型转化为对应的包装类对象。
• 拆箱：将包装类对象转化为对应的基本数据类型值。

示例：

Integer a = 100; // 自动装箱 -> Integer.valueOf(100)

int b = a; // 自动拆箱 -> a.intValue()

// 自动装箱和拆箱也适用于算术表达式
Integer n = 3;
n++; // 编译器将自动插入一条对象拆箱的指令，然后进行自增运算，最后再将结果装箱

装箱其实就是调用了包装类的valueOf()方法，拆箱其实就是调用了 xxxValue()方法。

API java.lang.Integer

• int intValue()

  将这个Integer对象的值作为一个int返回（覆盖Number类中的intValue方法）。

• static Integer valueOf(String s)

  返回一个新的Integer对象，用字符串s表示的整数初始化。指定字符串必须表示一个十进制整数。

关于自动装箱还有几点需要注意：

• 高频装箱拆箱（如循环）会产生大量临时对象，消耗内存和GC资源：

  // 错误示例：每次循环触发装箱
  Long sum = 0L;
  for (long i = 0; i < 1e6; i++) {
      sum += i; // sum = Long.valueOf(sum.longValue() + i)
  }
  
  // 正确优化：使用基本类型
  long sum = 0L;
  for (long i = 0; i < 1e6; i++) {
      sum += i;
  }
  

• 由于包装器类引用可以为null，所以自动装箱有可能会抛出一个NullPointerException异常：

  Integer n = null;
  System.out.println(2 * n) // throws NullPointerException
  

• 如果在一个表达式中混合使用Integer和Double类型，Integer值就会拆箱，提升为double，再装箱为Double：

  Integer n = 1;
  Double x = 2.0;
  System.out.println(true ? n : x); // 1.0
  

• 装箱和拆箱是编译器要做的工作，而不是虚拟机。编译器在生成类的字节码时会插入必要的方法调用。虚拟机只是执行这些字节码。

缓存池机制

缓存池是 Java 为优化包装类对象创建和内存消耗而设计的核心机制，通过预创建和复用常用数值的包装类对象，减少重复对象创建的开销。Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

Byte,Short,Integer,Long 这 4 种包装类默认创建了数值 [-128，127] 的相应类型的缓存数据，Character 创建了数值在 [0,127] 范围的缓存数据，Boolean 直接返回 TRUE or FALSE。

示例：

Integer a = 100; // Integer.valueOf(100)
Integer b = 100; // Integer.valueOf(100) 
Integer c = 200; // Integer.valueOf(200)
Integer d = 200; // Integer.valueOf(200)

System.out.println(a == b); // true
System.out.println(c == d); // false
System.out.println(c.equals(d)); //true 

Integer.valueOf()的缓存逻辑：

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i); // 超出缓存范围时创建新对象
}

缓存池机制：Java对-128 ~ 127范围内的Integer对象预先生成并缓存，a和b指向同一个缓存对象，a == b比较对象地址，返回true。200超出默认缓存范围（-128 ~ 127），Integer.valueOf(200)每次会创建新对象，c和d指向不同对象，c == d比较对象地址，返回false。

对于 Integer，可以通过 JVM 参数 -XX:AutoBoxCacheMax=<size> 修改缓存上限，但不能修改下限 -128。实际使用时，并不建议设置过大的值，避免浪费内存，甚至是 OOM（全称Out Of Memory， 即内存溢出）。

• 内存溢出：申请的内存超出了JVM能提供的内存大小，此时称之为溢出。
• 内存泄漏：申请使用完的内存没有释放，导致虚拟机不能再次使用该内存，此时这段内存就泄露了，因为申请者不用了，而又不能被虚拟机分配给别人用。

对于Byte,Short,Long ,Character 没有类似 -XX:AutoBoxCacheMax 参数可以修改，因此缓存范围是固定的，无法通过 JVM 参数调整。Boolean 则直接返回预定义的 TRUE 和 FALSE 实例，没有缓存范围的概念。

Character的缓存逻辑：

public static Character valueOf(char c) {
    if (c <= 127) { // must cache
      return CharacterCache.cache[(int)c];
    }
    return new Character(c);
}

Boolean的缓存逻辑：

public static Boolean valueOf(boolean b) {
    return (b ? TRUE : FALSE);
}

两种浮点数类型的包装类 Float,Double 并没有实现缓存机制：

Float a = 3f;
Float b = 3f;
System.out.println(a == b);// 输出 false

Double c = 1.2;
Double d = 1.2;
System.out.println(c == d);// 输出 false

下面这段代码的输出结果是什么？

Integer a = 40;
Integer b = new Integer(40);
System.out.println(a == b);

Integer a = 40自动装箱等价于Integer a = Integer.valueOf(40)，40在默认缓存范围内，所以a直接使用的是缓存中的对象，而Integer b = new Integer(40)会直接创建新的对象。因此，答案是false。