细说128陷阱

128陷阱

出现的场景：

public static void main(String[] args) {
		Integer a = 127;
		Integer b = 127;
		Integer c = 128;
		Integer d = 128;
		
		System.out.println(a == b);
		System.out.println(c == d);

	}

输出：

先不着急解释为什么一个输出true、一个输出false，先来了解一下什么java的基本类型和包装类型：
基本类型就是：int、short、long、byte、boolean、char，按说数据类型有这些基本类型就可以表示所有数据了，为什么还会有包装类呢，所谓包装类其实就是包装了各种有关操作方法的数据类型，包装类可以更方便的操作数据。而下面这段代码：

Integer a = 128

其中 a 是包装类Integer，‘127‘ 为基本类型int，int类型赋值给包装类Integer时，会自动完成类型转换，这个转换过程叫做装箱，反之叫做拆箱。
而 “128陷阱” 的奥妙就在此处：

还是以上面那一行代码为例，

Integer a = 128;
//等价于
Integet a = Integer.vauleOf(128);

就像代码看到的那样，当给包装Integer类 a 赋值基本类型int 128时，会自动调用Interget中的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);
    }

再讲源码之前补充一点：类用==号比较时，比较的是引用地址是否相同，包装类也是如此；
上面的源码表达的意思是，如果要付给包装类的值（整型）在IntegerCache的范围时，就会返回 IntegerCache类中的cache数组中的现有的引用地址；如果不在这个范围时，则会创建新的包装类对象，返回新的引用地址。
那么IntegerCache的范围是什么呢，可以看一下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() {}
    }

上述IntegerCache类代码中，可以看到设置范围最大值high、最小值low=-128，8-21行的意思是设置high为Integer能表示的最大值127；而后23-26行为申请一个长度为(127-(-128)) 的cache数组，并为cache数组中的每个元素设置为值从(-127-128)的包装类Integer；
所以，每回在比较值在(-127-128)的包装类时，系统会自动和已经在cache缓存数组中相同的值作为替换，由于相同的值在cache数组中的对象是同一个的，所以引用地址相同；

综上所述，也就不难明白，当比较(-127-128)之间的包装类（前提是基本类型int数据赋值），会调用valueOf方法，在Integer的valueOf()方法当中，在-128-127之间的数值都存储在有一个catch数组当中，该数组相当于一个缓存，当我们在-128-127之间进行自动装箱的时候，我们就直接返回该值在内存当中的地址，所以在-128-127之间的数值用==进行比较是相等的。而不在这个区间的数，需要新开辟一个内存空间，所以不相等。

**注：**系统之所以会设置这样一个已有的cache数组，是因为它可以在特定范围内重复使用频繁使用的整数对象，而不是每次都创建新的对象。通过这样做，它减少了内存消耗，并提高了在该范围内处理整数时的性能。