Integer缓存池（IntegerCache）

Integer 缓存是 Java 5 中引入的一个有助于节省内存、提高性能的特性。

Integer中有个静态内部类IntegerCache，里面有个cache[],也就是Integer常量池，常量池的大小为一个字节（-128~127）。JDK源码如下（摘自JDK1.8源码）：

/**
     * 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 -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) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low));
            }
            high = h;
 
            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }
 
        private IntegerCache() {}
    }

当创建Integer对象时，不使用new Integer（int i）语句，大小在-128~127之间，对象存放在Integer常量池中。

例如：Integer a = 10;

调用的是Integer.valueOf()方法，代码为：

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

这也是自动装箱的代码实现。JAVA将基本类型自动转换为包装类的过程称为自动装箱（autoboxing）。

实际上在 Java 5 中引入这个特性的时候，范围是固定的 -128 至 +127。后来在Java 6 后，最大值映射到 java.lang.Integer.IntegerCache.high，可以使用 JVM 的启动参数设置最大值。（通过 JVM 的启动参数 -XX:AutoBoxCacheMax=size 修改）

缓存通过一个 for 循环实现。从小到大的创建尽可能多的整数并存储在一个名为 cache 的整数数组中。这个缓存会在 Integer 类第一次被使用的时候被初始化出来。以后，就可以使用缓存中包含的实例对象，而不是创建一个新的实例(在自动装箱的情况下)。

测试情况：

               

int i = 10;
int i1 = 10;
Integer in1 = 10;
Integer in2 = 10;
Integer in3 = new Integer(10);
Integer in4 = new Integer(10);
Integer in5 = 199;
Integer in6 = 199;
        
System.out.println(i == i1);        // true
System.out.println(i == in1);        // true
System.out.println(i == in2);        // true
System.out.println(i == in3);        // true
        
System.out.println(in1 == in2);        // true
System.out.println(in5 == in6);        // false
        
System.out.println(in1 == in3);        // false
        
System.out.println(in3 == in4);        // false

在 Boxing Conversion 部分的Java语言规范(JLS)规定如下：
如果一个变量 p 的值属于：-128至127之间的整数(§3.10.1)，true 和 false的布尔值 (§3.10.3)，’u0000′ 至 ‘u007f’ 之间的字符(§3.10.4)中时，将 p 包装成 a 和 b 两个对象时，可以直接使用 a == b 判断 a 和 b 的值是否相等。

所有整数类型的类都有类似的缓存机制:

有 ByteCache 用于缓存 Byte 对象

有 ShortCache 用于缓存 Short 对象

有 LongCache 用于缓存 Long 对象

Byte，Short，Long 的缓存池范围默认都是: -128 到 127。可以看出，Byte的所有值都在缓存区中，用它生成的相同值对象都是相等的。

所有整型（Byte，Short，Long）的比较规律与Integer是一样的。

同时Character 对象也有CharacterCache 缓存 池，范围是 0 到 127。

除了 Integer 可以通过参数改变范围外，其它的都不行。