Java Integer 对象缓存及源码分析（Short、Long同理）

       JDK中Integer等包装类型是一种比较特殊的类，每一个基本数据类型都对应一个包装类。这里主要以jdk1.8的Integer类讲解，Integer的缓存及部分源码分析。

       首先看一下简单的代码

Integer i1 = 1;
Integer i2 = 1;

Integer i4 = 1111;
Integer i5 = 1111;

System.out.println(i1==i2);  （1）
System.out.println(i4==i5);  （2）

结果：（1）true （2）false

为什么是这样？

首先我们要明白表达式的转换。Integer i = 1; 等价于 Integer i = Integer.valueOf(1);  这个很重要,明白这个我们就继续沿着代码看下去。

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

可以看到如果值i大于IntegerCache.low（-128） 且小于IntegerCache.high（可自定义，默认127），直接从IntegerCache获取缓存。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");//#1
            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; //#2

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++) //#3
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127; //#4
        }

        private IntegerCache() {}
    }

1、#1到#2代码，判断是否设置了Integer缓存的最大的值，如果设置了java.lang.Integer.IntegerCache.high的值，high将等于它，但不能大于Integer的最大值Integer.MAX_VALUE。

2、#3代码将建立大小为(high - low) + 1的缓存对象，存放在cache数据组中。

3、#4 进行了大小校验。

所以 例子输出结果：（1）true （2）false。就不难理解了，1小于等于127 获取是IntegerCache中的new Integer(1); 对象。而1111大于127获取的是直接在堆里的对象new Integer(1111);

另外注意：

Integer i1 = 1;
int i2 = 1;

Integer i4 = 1111;
int i5 = 1111;

System.out.println(i1==i2);  （1）
System.out.println(i4==i5);  （2）

这里输出：（1）true （2）true。

Integer 的对象一旦与基本数据类型比较，直接会转化为int类型，在Integer源码里是

public int intValue() {
        return value;
    }

所以无论是Integer i = 1; 、Integer i = new Integer(1); 、Integer i = 1111;、Integer i = new Integer(1111); 与相对应int类型进行==操作结果都是true，这个一定要注意。

总结：为了避免这种问题，在对象==操作的时候，可以尽量使用Integer对象的intValue方法。

同理Short、Long类似原理一致，这里就不做分析了。