Integer用==比较时127相等，而128不相等的原因

一、经典面试题

1.1 代码

public class IntegerTest {
    private static void testIntCompareInteger() {
        int _127 = 127;
        int _128 = 128;
        Integer integer_127 = 127; ///自动装箱，相当于 "Integer integer_127 = new Integer(127)" ,由于 127在缓存范围内，直接使用数组中的元素。缓存可以提高效率
        Integer integer_127_2 = 127;
        Integer new_integer_127 = new Integer(127);

        Integer integer_128 = 128;
        Integer integer_128_2 = 128;
        Integer new_integer_128 = new Integer(128);

        System.out.println("_127 == integer_127:" + (_127 == integer_127));//true
        System.out.println("_127 == new_integer_127:" + (_127 == new_integer_127));//true
        System.out.println("integer_127 == integer_127_2:" + (integer_127 == integer_127_2));//true ?
        System.out.println("integer_127 == new_integer_127:" + (integer_127 == new_integer_127));//false

        System.out.println("_128 == integer_128:" + (_128 == integer_128));//true
        System.out.println("_128 == new_integer_128:" + (_128 == new_integer_128));//true
        System.out.println("integer_128 == integer_128_2:" + (integer_128 == integer_128_2));//false ?
        System.out.println("integer_128 == new_integer_128:" + (integer_128 == new_integer_128));//false
    }

    public static void main(String[] args) {
       testIntCompareInteger();
    }
}

1.2 运行结果

默认情况下的运行结果如下：

_127 == integer_127:true
_127 == new_integer_127:true
integer_127 == integer_127_2:true
integer_127 == new_integer_127:false
_128 == integer_128:true
_128 == new_integer_128:true
integer_128 == integer_128_2:false
integer_128 == new_integer_128:false

1.3 Integer用==比较时，127相等，而128不相等？

从上面运行结果得到的结论是：Integer == 比较时，127相等，而128不相等。为什么会这样呢？因为Integer integer_127 = 127;相当于 Integer.valueOf(127) ，所以直接看 Integer.valueOf()源码。

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

	/**
	* Integer 里面的静态内部类，随着类的加载而加载，相当于提前加载好了
	* [-128, 127] 之间的数的对象。当我们在调用构造器“new Integer()”时，就会
	* 优先使用缓存好的数，没有才会 重新"new 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] 之间共计256的数的对象，可以通过添加虚拟机参数 -XX:AutoBoxCacheMax=127 赋值一个大于等于127的整数(源码默认最小取127)，修改Integer缓存的最大值，所以只要在这个范围内的数都是取的同一对象,所以"127相等"；而落在之外的数，才会重新new Integer()，新new出来的对象地址值会变，所以"128不相等"。

二、结论

1. Integer 默认缓存 [-128 , 127] 的数，提前 new 好了；
2. VM参数 -XX:AutoBoxCacheMax=127 可以控制 Integer 的最大值;
3. Integer是引用数据类型，'=='比较的是地址值；
4. Integer是包装类，java包装类都重写好了.equals()方法，比较值一定要用 .equals()方法；