Integer的两种创建方式比较

• 当我们使用Integer创建对象时，可以使用两种方式进行创建
  ①Integer i = new Integer(10);
  ②Integer i = 10;
  那么这两种方式又有什么区别呢，一个是new出来的，一个是直接赋值出来的。
  要想知道原理，必须了解new关键字的作用：在堆内存开辟新空间，将对应空间的地址赋给变量，该变量存储在栈内存中。如果是直接赋值方式，则不存在堆内存的说法，直接在栈内存中创建变量。
  下图是堆栈内存图
  
  所以以上两种创建Integer类型对象时，一个会在堆内存开辟新空间，另一个不会。
• 那么根据以上知识，我们看看一下代码的输出结果是什么：

	Integer i1 = new Integer(127);
	Integer i2 = new Integer(127);
	System.out.println(i1 == i2);
	System.out.println(i1.equals(i2));

结果为：false、true。
因为==运算符比较的是两者地址，因为均是new出来的对象，在堆内存中两者地址不同，故为false；equals()方法无论如何均是比较值大小，故为true。

• 然后我们再看以下代码：

	Integer i3 = 127;
	Integer i4 = 127;
	System.out.println(i3 == i4);
	System.out.println(i3.equals(i4));

结果为：true、true。根据如上说法，直接赋值保存的是值，与地址无关，故均相等。

• 但我们再看看如下代码：

	Integer i5 = 128;
	Integer i6 = 128;
	System.out.println(i5 == i6);
	System.out.println(i5.equals(i6));

结果却为：false，true。
难道128 不等于128吗？我们首先要知道，直接赋值等同于调用valueOf方法，即等价于Integer i = Integer.valueOf(128)，然后我们不妨再查看一下Integer源码：

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

继续查看IntegerCache类：

 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() {}
    }

可以看到代码中含有-128和127的字样，我们可以初步理解为：Integer为我们定义了一个缓冲池，将-128~127范围内的值存放至缓冲池中，当直接赋值或调用valueOf方法进行创建该范围内的值时，会直接从缓冲池获取值，无需在堆内存中开辟新空间；若不在范围内，则需开辟新空间存放变量。

• 综上所述，因为我们定义的数据128超出了127，故其需在堆内存开辟新空间，保存对象，并且两者地址不同，故比较地址时的结果不同，返回false。
• 进言之，当我们定义的数据为127，则直接在缓冲池中获取数据赋给Integer对象，因此比较时返回true。