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

我们知道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;
}

包装类的缓存

通过查看包装类源码，我们发现Java为了在自动装箱时避免每次去创建包装类型，采用了缓存技术。即在类加载时，初始化一定数量的常用数据对象(即常说的热点数据)，放入缓存中，等到使用时直接命中缓存，减少资源浪费。Java提供的8种基本数据类型，除了float和double外，都采用了缓存机制。其实原因也很简单，因为浮点型数据，热点数据并不好确定，故并未采用。
各包装类型缓存范围如下：

包装类型	缓存值
Character	0~127
Byte,Short,Integer,Long	-128 到 127
Boolean	true,false

拓展

1. 为什么是Integer.MAX_VALUE - (-low) - 1？

// MAX_VALUE = 0x7fffffff，即(2^32)-1
// 取较小值：为什么Integer.MAX_VALUE - (-low) - 1？
h = Math.min(i, Integer.MAX_VALUE - (-low) - 1);

因为缓存的下限是-128，程序中已经写死，不能用过配置修改，缓存采用数组来存放需要缓存的Integer对象，java中数组最大长度 = int的最大值，int占用32位，最大值为(2^32)-1即2147483647，所以 h - low <= MAX_VALUE - 1，由此得出h的最大值为Integer.MAX_VALUE - (-low) - 1。

2. assert断言
assert格式：
1）assert [boolean 表达式]
如果[boolean表达式]为true，则程序继续执行。
如果为false，则程序抛出AssertionError，并终止执行。
2）assert[boolean 表达式 : 错误表达式 （日志）]
如果[boolean表达式]为true，则程序继续执行。
如果为false，则程序抛出java.lang.AssertionError，输出[错误信息]。

// 断言有什么作用？
// 由assert的语义可知，此处保证IntegerCache.high最小值为127。
assert Integer.IntegerCache.high >= 127;

3. **疑问：**Integer缓存的bug？
   在网上看到一篇文章Integer中IntegerCache使用及分析，文章末尾提到了这段代码：

  public static void main(String[] args) throws Exception {
        Class<?> clazz = Integer.class.getDeclaredClasses()[0];
        Field field = clazz.getDeclaredField("cache");
        field.setAccessible(true);
        Integer[] cache = (Integer[]) field.get(clazz);
        cache[132] = cache[133];
        int a = 2;
        int b = a + a;
        System.out.printf("%d+%d=%d", a, a, b);
        System.out.println();
        System.out.println(a + "+" + a + "=" + b);
    }

查看printf方法源码发现方法形参为Object对象类型，而入参为int基本类型，猜测发生自动装箱，下面我们写一段代码继续验证：

  public static void main(String[] args) {
        try {
            int a = 2;
            int b = 4;
            Class<?> clazz = Integer.class.getDeclaredClasses()[0];
            Field field = clazz.getDeclaredField("cache");
            field.setAccessible(true);
            Integer[] cache = (Integer[]) field.get(clazz);
            cache[132] = cache[133];
            Object obj1 = a;
            Object obj2 = b;
            System.out.println(obj1);
            System.out.println(obj2);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

通过断点及输出结果我们发现int转为Object类型时发生了自动装箱，而4在[-128,127]范围内，多态情况下Object.toString调用了Integer的toString方法，输出了缓存中的5。（破获大案/笑哭）