Integer缓存的那些事儿

首先我们看看下面的输出会是什么

public static void testIntegerCache(){
        Integer a = 66;
        Integer b = 66;
        System.out.println(a == b);

        Integer c = 166;
        Integer d = 166;
        System.out.println(c == d);

        Integer e = 166;
        int f = 166;
        System.out.println(e == f);
    }

结果如下

Connected to the target VM, address: '127.0.0.1:56263', transport: 'socket'
Disconnected from the target VM, address: '127.0.0.1:56263', transport: 'socket'
true
false
true

Process finished with exit code 0

为什么会是这个结果呢，这个就要说到integer的缓存

 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的内部有一个静态的内部类IntegerCache，看源码可以知道，如果没有自定义的配置，那么缓存的将是【-128，127】，接下来看看自动装箱的过程

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

首先从缓存中获取，如果没有，就 new 一个
那么下面这个等于true可以理解，和 string 的有点相似，string是常量池

 Integer a = 66;
 Integer b = 66;
 System.out.println(a ==b);

66缓存中就可以直接获取，所以直接返回true

Integer c = 166;
Integer d = 166;
System.out.println(c==d);

166是大于127的。在缓存中获取不到，直接new ，很明显，不相等，false

Integer e = 234;
int f = 234;
System.out.println(e == f);

234是大于127的，所以integer的234肯定是new的
但是 f 是基本数据类型，他们相比较，会进行拆箱的操作，即调用intValue()

private final int value;
public int intValue() {
        return value;
    }

直接返回基本数据类型，进行比较