JDK源码分析　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(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 i=-128;
Integer j=-128;
System.out.println(i.hashCode());
System.out.println(j.hashCode());
System.out.println(i==j);

返回结果-128 -128 true  在Integer的内部类中，int数的hashcode()值都是自身。　返回结果之所以为true，是因为java为int创建类一个区域Integer cache[],里面存放了-128到127的数，当我们直接使用时，都是直接引用该区域的数，所以比较地址时是不变的。这种缓存策略只针对自动装箱有用，而直接new Integer(1)时，是在堆内存创建对象，所以地址不一样。

Integer i=-12;
Integer j=Integer.valueOf(-12);
System.out.println(i.hashCode());
System.out.println(j.hashCode());
System.out.println(i==j);

结果返回 -12 -12 true

看一下Integer.valueOf()的实现方式：

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一个对象。

Javadoc 详细的说明这个类是用来实现缓存支持，并支持 -128 到 127 之间的自动装箱过程。最大值 127 可以通过 JVM 的启动参数 -XX:AutoBoxCacheMax=size 修改。 缓存通过一个 for 循环实现。从小到大的创建尽可能多的整数并存储在一个名为 cache 的整数数组中。这个缓存会在 Integer 类第一次被使用的时候被初始化出来。以后，就可以使用缓存中包含的实例对象，而不是创建一个新的实例(在自动装箱的情况下)。

如果修改JVM启动参数　-XX:AutoBoxCacheMax=1000  那么就将-128到1000放入了cache中。

这种缓存行为不仅适用于Integer对象。我们针对所有整数类型的类都有类似的缓存机制。
有 ByteCache 用于缓存 Byte 对象
有 ShortCache 用于缓存 Short 对象
有 LongCache 用于缓存 Long 对象
有 CharacterCache 用于缓存 Character 对象
Byte，Short，Long 有固定范围: -128 到 127。对于 Character, 范围是 0 到 127。除了 Integer 可以通过参数改变范围外，其它的都不行