【Java基础】Integer.valueOf(100) == Integer.valueOf(100)为什么等于true

基础：

当包装类与基本数据类型比较，会自动将包装类拆箱为基本数据类型，以下全为true

​int a = 1000;
Integer b = 1000;
Integer c = new Integer(1000);
Integer d = Integer.valueof(1000);
​
System.out.println(a == b);
System.out.println(a == c);
System.out.println(a == d);

直接赋值:

Integer i = 100; 

如下图我们通过javap分析字节码，可以发现自动装箱使用的是Integer.valueof(int value);方法来创建Integer对象。

0: aload_0
1: invokespecial #1     // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush        100
7: invokestatic  #2     // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
10: putfield      #3    // Field i:Ljava/lang/Integer;
13: return

valueof赋值：

通过直接赋值的字节码分析得出底层使用的valueof赋值，那么，现在来看看valueof赋值又是怎么实现的？

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

通过查看valueof源码，我们发现，Integer中有一个私有静态内部类IntegerCache，在[-128,127]范围内，直接从缓存中获取已创建好的Integer对象，不在此范围内直接new一个Integer对象。
所以，我们在Integer.valueof(100)的创建的对象，其实是我们从缓存中获取的，那么不管你创建多少次，都是拿到的同一个对象。

new对象赋值：

相比这种方法创建对象，大家再熟悉不过了，直接通过构造方法创建，这里就不多介绍。

• ​补充：jdk1.9后，构造方法创建Integer对象，官方已不推荐使用，valueof(int)将会是更好的选择。

​总结：

1. 直接赋值底层使用valueof方法给Integer对象赋值。
2. 在[-128,127]范围内，直接从缓存中获取已创建好的Integer对象。
3. 在[-128,127]范围外，直接使用构造方法创建对象。