【Java】从源码上解释128陷阱

一、理论上分析128陷阱

1.什么是装箱？

装箱就是把基本数据类型自动转换成引用类型，比如 定义一个数值类型 Integer num = 1 它自动把int类型的数字转换为对应的引用类型，这就是装箱。

2.简单阐述128陷阱

在java中的整型包装类当中 存在一个128陷阱 ，它是指在范围-128 ~ 127之间内的整数值(包含-128和127) 在自动装箱时会 被缓存，而超出这个范围内 不会被缓存，

这是因为Integer 的valueOf()方法当中，如果数值在-128 ~ 127之间的数据都存储在一个catch数组中，该数组相当于一个缓存，当我们在-128~127之间进行自动装箱的时候，程序就之间返回该值在数组中的内存地址 所以在-128 ~ 127之间的数值用 == 比较是相等，而不在这个区间的，需要新开辟一个内存空间，所以不相等

代码如下：

Integer a  = 128；
Integer b = 128；
System.out.println(a == b);

结果如下：

二、从源码角度分析128陷阱

Integer在内部定义了一个IntegerCache的方法，用于缓存范围-128 ~ 127之间的Integer对象，这个缓冲池的初始默认是-128 ~ 127
也可以根据JVM参数来调整缓存池大小

点击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.valueOf() 方法将一个整数赋给Integer类型的变量时，如果整数在-128 ~ 127范围内的，则在缓存池里，不需要新建一个Integer对象。如果超出这个范围，就需要新建一个Integer对象，无法从当前缓冲池获取。

结论

128陷阱 发生的原因 ：当数值超过了-128 ~ 127 范围，两个不同的整数被装箱之后得到的Integer对象不是同一个，从而用“==” 来比较时，得出的是false。而在范围内的 两个整数 可以直接在缓冲池中获取，是在同一个Integer对象，所以 是 true。