拆箱和装箱

// 手动装箱
Integer integer = new Integer(10);
// 手动拆箱
int i = integer.intValue();

// 自动装箱，通过 Integer.valueOf() 完成
Integer integer = 10;
// 自动拆箱，通过 Integer.intValue() 完成
int i = integer;

• IntegerCache

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

private static class IntegerCache {
    // 缓存的最小值，默认为 -128
    static final int low = -128;
 
    // 缓存的最大值，默认为 127，但可以通过 JVM 参数配置
    static final int high;
    static final Integer cache[];
 
    static {
        // 默认情况下 high 值为 127
        int h = 127;
 
        // 通过系统属性获取用户可能配置的更高的缓存上限
        // integerCacheHighPropValue 是一个字符串，代表配置的高值
        int i = parseInt(integerCacheHighPropValue);
 
        // 确保缓存的最高值至少为 127
        i = Math.max(i, 127);
 
        // 设置 high 的值，但不能超过 Integer.MAX_VALUE - (-low) - 1
        h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
        high = h;
 
        // 初始化缓存数组，大小为 high - low + 1
        cache = new Integer[(high - low) + 1];
 
        // 填充缓存，从 low 开始，为每个值创建一个 Integer 对象
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
 
        // 断言确保 high 的值至少为 127，这是 Java 语言规范要求的
        assert IntegerCache.high >= 127;
    }
}
 

int a = 100;
Integer b = 100;
// 基本数据类型和包装类型进行 == 比较，这时候 b 会自动拆箱，直接和 a 比较值
// true
System.out.println(a == b);
 
// -128 到 127 之间的数会从 IntegerCache 中取，然后比较，100 在这个范围之内
Integer c = 100;
Integer d = 100;
// true
System.out.println(c == d);
 
// 200 不在这个范围之内，所以 new 出来了两个 Integer 对象
c = 200;
d = 200;
// false
System.out.println(c == d);

• 当需要进行自动装箱时，如果数字在 -128 至 127 之间时，会直接使用缓存中的对象，而不是重新创建一个对象
• 反例

long t1 = System.currentTimeMillis();
Long sum = 0L;
// sum 是个 Long 型，而 i 为 int 类型
for (int i = 0; i < Integer.MAX_VALUE;i++) {
    // 先把 i 强转为 long 型，然后再把 sum 拆箱为 long 型进行相加操作
    // 之后再自动装箱为 Long 型赋值给 sum
    sum += i;
}
long t2 = System.currentTimeMillis();        
System.out.println(t2-t1);