0.问题引出
先看一段测试代码，猜一下输出会是什么：
public class Test {
public static void main(String[] args){
Integer i1 = 127;
Integer i2 = 127;
Integer i3 = Integer.valueOf(127);
Integer i4 = new Integer(127);
Integer i5 = 128;
Integer i6 = 128;
System.out.println(i1 == i2);
System.out.println(i1 == i3);
System.out.println(i1 == i4);
System.out.println(i5 == i6);
}
}
不许偷看…
答案揭晓:
true
true
false
false是不是有点迷糊了，i1、i2虽然包装的值相同，但是明明是两个对象，为什么会输出true。还有i3和i1为什么也输出true。i1、i4，i5、i6包装的值也相同啊，为什么就变成false了啊。这些奇怪的输出都是cache机制惹的祸，别着急，待我们细细分解。
1.cache机制到底是什么意思
从Java 5开始，为了节省内存和提升Integer类性能，增加了cache机制。取值在一定范围（默认为[-128~127]，咦，我为什么要说默认？）内的Integer对象会被缓存起来，以后这些对象就可以重复使用。cache机制只有在自动装箱（autoboxing）、以及手动装箱（手动是我自己的说法，即调用Integer.valueOf(int i)方法）时才会起作用。
用上面这段话解释我们测试程序的输出，由自动装箱和手动装箱创建的值为127的Integer对象指向同一个对象，这就是为什么我们前两行输出会是true。而i4是直接创建的Integer对象，不会用到cache机制，i5、i6的值超出cache范围，所以后两行输出false。
好奇的你会问了，为什么要这样做。注意前面加黑的两个词，对，就是节省内存和提升性能。人们频繁使用的数常常是那些取值比较小的，Java设计者基于这样的统计学理论，将[-128,127]之间的数缓存起来，以后使用的时候直接从缓存中取出对象索引，而不用再重新创建。哎，不是说节省内存和提升性能吗，开头的小程序只用到了6个Integer对象，你一下子在缓存里搞出来256个对象，骗子。当然了，得附加一句，只有在程序很大的时候，cache机制的优点才能体现出来。
写到这里，cache是什么我们已经清楚了，接下来更进一步，看一看cache机制是怎么实现的。
2.cache机制如何实现
在Integer类的源码中，我们看到了一个静态内部类IntegerCache。
/**
* Cache to support the object identity semantics of autoboxing for values between
* -128 and 127 (inclusive) as required by JLS.
*
* The cache is initialized on first usage. The size of the cache
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
* During VM initialization, java.lang.Integer.IntegerCache.high property
* may be set and saved in the private system properties in the
* sun.misc.VM class.
*/
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(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() {}
}哈，也没有什么神奇的嘛，就是在第一次调用IntegerCache类的时候，把所有[low,high]范围内的对象一次性创建好，存到cache[]数组中。以后使用的时候，直接返回对象而不是新建。
前面说到，只有在自动装箱和手动装箱时才会用到cache机制，搜索源码也证实了这一说法，IntegerCache类只在valueOf方法调用时才用到。先看Integer.valueOf(int i)的源码:
/**
* 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);
}和我们预想的一样，方法参数如果在cache范围内，直接返回，否则new一个新对象。手动装箱解决了，那么自动装箱是怎么利用cache机制的呢。
用jdk自带的反编译工具javap对我们.class进行反编译。(javap是jdk自带的反编译工具，可以用javap -help查看指令帮助，这里我们用javap -c)，进入Test.class文件所在目录，执行
javap -c Test
输出中我们找到了这样的内容：
……
public static void main(java.lang.String[]);
Code:
0: bipush 127
2: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
…….
原来自动装箱也是在字节码层面调用了Integer.valueOf()方法。
此外，在IntegerCache源码中，我们看到了这样一行
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty(“java.lang.Integer.IntegerCache.high”);
说明cache数组的上界high是可以改变的。利用jvm参数[-XX:AutoBoxCacheMax=size]可以改变上界。从命令行运行Test.class
java -XX:AutoBoxCacheMax=1000 Test
输出变为
true
true
false
true3.其他
至此，Integer的cache机制算是说清楚了。应该注意，除了Integer，还有以下几种包装类也有cache机制：Byte、Short、Long、Character。不过有一点区别，这四类的cache[]数组长度都是固定的，不可改变。且Byte、Short、Long的cache范围相同，[-128,127]，Character则为[0,128]。Boolean取值只有2个，valueOf使用两个常量来自动装箱。