Java之Integer内部缓存

在Java中，每次创建对象都要进行内存分配操作，为了减少频繁地创建对象，许多地方采用池来存放对象，如String中的字符串池，对于基本类型，对应的包装类中皆有缓存来避免频繁创建对象，如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) {
                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() {}
    }

这个类的作用就是缓存-128~127这些常用数值，当调用valueOf(int i)方法时，先查看是否在此范围内，如果是，从池中返回，不是则新建对象，如下：

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);
    }

但是，如果直接使用new创建对象，则不会从缓存中查询，如下：

/**
 * @Auothor wzx
 * @Date 2017/3/12 0012
 */
public class IntegerTest {

    @Test
    public void test() {
        Integer i1 = 10;
        Integer i2 = Integer.valueOf(10);
        Integer i3 = new Integer(10);
        System.out.println(i1 == i2);
        System.out.println(i2 == i3);
    }

}

输出结果：

true
false

此外，还可以设置vm参数来设置缓存的最大值，如：

-Djava.lang.Integer.IntegerCache.high=2000

参考
http://howtodoinjava.com/core-java/related-concepts/object-initialization-best-practices-internal-caching-in-wrapper-classes/