整数缓存池

int num1=100;//基本类型的定义
Integer num2=100;
Integer num3=Integer.valueOf(100);
//同一个对象，都在数组里面
Integer num4=new Integer(100);
Integer num5=new Integer(100);
System.out.println(num2==num3);//true
System.out.println(num3==num4);//false
System.out.println(num4==num5);//false

上面结果应该很容易想到，但是如果我再定义两个对象，并且值是128，那会咋样呢？

Integer num6=128;
Integer num7=128;
System.out.println(num7==num6);

输出是false，为什么呢？这时候我们可以看一下，valueOf的底层代码：

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

可以看到它是调用了IntegerCache静态类的两个属性low和high来返回不同的结果，如果i在low和high之间返回数值，超出就返回一个新的对象，那我们可以点开看看这个类的取值范围：

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

可以看到，比较的范围是-128~127。当超出这个范围的时候，就会给创建一个新的对象，所以才会出现num7！=num6的结果。

对于Short，Long，Byte也都是用的整数缓存池，范围都是-128~127，字符型包装类Character则是0到127