【教3妹学java】5.Integer和int之间判相等的区别,

2哥：3妹，Integer和int你了解吗？
3妹：一个装箱一个拆箱啊，这个是最基本的，我早就学习过了。
2哥：那我有几个问题要考考你：

• int和int， Integer和Integer， int和Integer分别怎么判断相等？
• new Integer() 和 Integer.valueOf()有什么区别？
• Integer类会进行缓存吗？
  3妹：emmm……灵魂三问啊，这个我要想一下了。
  2哥：别着急，让我们通过几个例子来学习下。

int和int， Integer和Integer， int和Integer分别怎么判断相等？

int与int
两边都是基本类型，可直接用==判断

int和Integer
Integer会自动拆箱为int，所以也可以直接用==判断

Integer和Integer
（1）如果数值范围在[-128,127]之间，可以直接用==
因为JVM会维护这个范围内的缓存，比如第一个Integer是127，会存放在缓存中；在创建第二个Integer时会直接返回缓存的127，所以两者是相等的
（2）其他范围的Integer，不能用==，必须用equals

new Integer() 和 Integer.valueOf()有什么区别？

 public static void main(String[] args) {
        Integer a = new Integer(127);
        Integer b = new Integer(127);
        Integer c = Integer.valueOf(127);
        Integer d = Integer.valueOf(127);
        System.out.println("a==b, " + (a == b));
        System.out.println("c==d, " + (c == d));
        System.out.println("a==c, " + (a == c));

        Integer e = Integer.valueOf(128);
        Integer f = Integer.valueOf(128);
        System.out.println("e==f, " + (e == f));

    }

输出结果：

a == b, false
c == d, true
a == c, false
e == f, false

通过new Interger()创建Interger对象，每次返回全新的Integer对象
通过Interger.valueOf()创建Interger对象，如果值在-128到127之间，会返回缓存的对象(初始化时)。如果值不在-128到127之间，Interger.valueOf()也会返回全新的Integer对象。

Integer类会进行缓存吗？

通过上面的例子我们已经知道，Integer.valueOf()创建的在-128到127之间的对象会有缓存，那么原理是什么呢？
实现原理：Integer类中有一个静态内部类IntegerCache，在加载Integer类时会同时加载IntegerCache类，IntegerCache类的静态代码块中会创建值为-128到127的Integer对象，缓存到cache数组中，之后调用Integer#valueOf方法时，判断使用有缓存的Integer对象，有则返回，无则调用new Integer()创建。
PS：（127是默认的边界值，也可以通过设置JVM参数java.lang.Integer.IntegerCache.high来进行自定义。）

public static Integer valueOf(int i) {
    if (i >= IntegerCache.low && i <= IntegerCache.high)
            //cache是一个Integer数组，缓存了-128到127的Integer对象
        return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
}

//IntegerCache是Integer类中的静态内部类，Integer类在加载时会同时加载IntegerCache类，IntegerCache类的静态代码块中会
private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // 127是默认的边界值，也可以通过设置JVM参数java.lang.Integer.IntegerCache.high来进行自定义。
            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);
                    // cache数组的长度不能超过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++);

            // high值必须大于等于127，不然会抛出异常
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }