包装类的缓存及自动装箱、拆箱

我们知道Java有八个基础类型，同时为每个基础类型提供了对应的包装类型，对应关系如下：

基础类型	包装类型
byte	Integer
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

什么是自动装箱/拆箱？

自动装箱：将基本类型的变量赋值给对应的包装类
自动拆箱：将包装类对象直接赋值给对应的基础类型变量

什么情况下会触发自动装箱？

基本类型赋值给包装类型时会触发自动装箱，调用包装类型的valueOf()方法。

Integer i = 100; 
// 上面的代码相当于：
Integer i = Integer.valueOf(100);

什么情况下会触发自动拆箱？

当包装类参与运算时触发自动拆箱，调用对应的xxxValue()方法。
包装类与基本类型比较、或赋值给基本类型时，触发自动拆箱

Integer i = 100; 
i ++; // i参与运算，自动拆箱
int j = i;// i赋值给基本类型，自动拆箱

解释了自动装箱、拆箱，我们来看一道经典面试题：

Integer i01 = 59;// 相当于  Integer.valueOf(59);
int i02 = 59;
Integer i03 = Integer.valueOf(59);
Integer i04 = new Integer(59);
System.out.println(i01 == i02);
System.out.println(i01 == i03);
System.out.println(i03 == i04);
System.out.println(i02 == i04);

我们一起分析一下：
i01 == i02，因为i02为基本类型，i01自动拆箱，应该返回true；
i01和i03为两个对象，应该返回false；（这个结论是错误的，后面会解释）
i03、i04为两个不同对象，应该返回false；
i02 == i04，i04自动拆箱，应该返回true；
但实际运行结果是：

true
true
false
true

为什么i01 == i03 会返回true呢？我们知道引用类型“==”比较的是对象的地址即两者是不是同一个对象，这两个为什么会是同一个对象？我们来看一下Integer源码（JDK8）中valueOf(int i)方法是怎么实现的：

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 {
    static final int low = -128;// 缓存池最小值，默认-128
    static final int high;// 缓存池最大值，默认127
    static final Integer cache[];// 缓存数组
    static {
        int h = 127;
        //可通过修改参数"java.lang.Integer.IntegerCache.high"来设置缓存池的最大值
        String integerCacheHighPropValue = 
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                // MAX_VALUE = 0x7fffffff，即(2^32)-1
                // 取较小值：为什么Integer.MAX_VALUE - (-low) - 1？
                h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);
            } catch (NumberFormatException nfe) {
            // If the property cannot be parsed into an int, ignore it.
            // 如果不能转换成int类型，就忽略它
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for (int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);
        // 断言有什么作用？
        assert Integer.IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

valueOf(int i)方法先判断了变量i的值是否在[IntegerCache.low,IntegerCache.high]范围内：
如果在范围内，则返回的IntegerCache.cache[i + (-IntegerCache.low)];
不在范围内则返回 new Integer(i);
通过IntegerCache内部类的源码我们得知，默认情况下在[-128,127]会被直接放到缓存中，创建在这个范围内的包装类型时会直接返回创建好的对象，并不会重新创建对象。这就是为什么i01 == i03了。
那为什么i04!=i03呢？i04直接调用了构造方法，返回的新建的对象，并不是从缓存中得到的，所以i04和i03不相等。

private final int value;
public Integer(int value) {
    this.value = value;
}