在上篇《 》文章中分享了java中的Integer中的自动拆箱产生的NPE，其实对于所有的包装类来说都是一样的，都会产生这样的问题，大家需要举一反三，做学问学知识要懂得反思总结。
一、前情回顾
先回顾下上次的知识点，
其他的包装类，小伙伴们自己总结
二、Integer的本地缓存
好了话不多说，书接上回，开始这次的分享，上次说到在自动装箱的时候还大有玄机，这个玄机就是本地缓存。这个玄机在自动装箱的方法中，如下图
/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
先看下其方法说明吧，用我大学英语六级的水平给大家翻译下，献丑了大家莫怪，
返回一个代表指定int的Integer对象，如果一个新的Integer实例不是必需的，这个方法通常使用构造方法来生成，另一方面，这个方法通常为了节省空间和实际会缓存一些经常使用的值
这个方法会缓存[-128~127]之间的值，也可能会缓存这个范围以外的值
翻译的太差劲了，大体意思是如果参数在[-128,127]间则会从缓存中取，如果不在则直接生成Integer的实例。 还有很重要的一点最大值可以配置。
看方法的逻辑也是这样的，看下Integer初始化缓存的代码，在Integer中有静态内部类IntegerCache，代码如下，
private static class IntegerCache {
//缓存区间，最小值
static final int low = -128;
//缓存区间，最大值，可配置
static final int high;
//缓存
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
//获得配置的缓存区间最大值
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
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
//for循环，生成缓存
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}
上面的代码加注释足以说明一切，不再一一解释了，默认情况下Integer中存在[-128,127]范围内的的256个缓存Integer实例。
三、验证本地缓存
上面说到，在Integer中存在缓存， 重要的一点是在调用valueOf()方法的时候才会校验缓存， valueOf方法共有以下几个
重要声明，在使用构造方法的时候是没有缓存的，看构造方法
/**
* Constructs a newly allocated {@code Integer} object that
* represents the specified {@code int} value.
*
* @param value the value to be represented by the
* {@code Integer} object.
*/
public Integer(int value) {
this.value = value;
}
那么在验证的时候就不能使用构造方法的方式，需要使用自动装箱的方式。
1、构造方法没有缓存
public class TestIntegerConstruct {
public static void main(String[] args) {
Integer i1=new Integer(1);
Integer i2=new Integer(1);
System.out.println(i1==i2);
}
}
打印结果为，
false
Process finished with exit code 0
打印出来为false，说明i1和i2为两个不同的对象。
2、valueOf()方法才有的缓存
使用valueOf构造两个Integer对象，
public class TestValueOf {
public static void main(String[] args) {
Integer i1=1;
Integer i2=1;
System.out.println(i1==i2);
}
}
打印结果为，
true
Process finished with exit code 0
说明i1和i2为同一个实例，这里使用的是==来判断，对引用对象来说判断的不正是其地址。
多说一点，这里两个引用类型的比较，大家不要像我这里似的，使用“==”，请使用equals方法，使用“==”比较的是内存地址，在大部分情况下，内存地址肯定不相等，而使用equals方法就说不准了，equals方法比较的是什么？
3、Integer的equals方法
看下Integer的equals方法比较的是什么东西
public boolean equals(Object obj) {
if (obj instanceof Integer) {
return value == ((Integer)obj).intValue();
}
return false;
}
看到没，搜先判断的是类型，然后调用其intValue方法，也就是拆箱，比较的是Integer中value的值，也就是数值的比较。
四、总结
本文，分享了Integer中的本地缓存，需要明白以下几个问题，
1、什么时候会用到本地缓存？–调用valueOf方法的时候
2、本地缓存的大小；–默认为[-128,127]，最大值可设置
3、equals方法比较的是什么；–比较的是值得大小，非内存地址
