源码角度解析128陷阱

1、什么是128陷阱？

128陷阱指的是2个Integer对象直接用==判定，在-128到127范围内为true，超出这个范围为false。

Integer a = 10;
Integer b = 10;
System.out.println(a == b);       // 输出 true

Integer c = 128;
Integer d = 128;
System.out.println(c == d);       // 输出 false

2、为什么会产生128陷阱？

在JDK1.5之后，编译器提供了自动拆箱和装箱的功能，当创建Integer类型的对象时，会进行自动装箱，如图：

Integer b = 128
//Integer b = Integer.valueOf(10)

下面时Integer源码：

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 =  
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");  
        if (integerCacheHighPropValue != null) {  
            try {  
                int i = parseInt(integerCacheHighPropValue); 
                //最大值最小是127 
                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，IntegerCache在加载时会从-128到127构建一个Integer数组存起来，当自动装箱时，就会直接从这个数组里面取对象使用，此时两个Integer对象指的就是相同的对象，所以两个对象进行==判定返回就是true，而超过这个范围之后创建一个新的对象，值相同，但是地址不同，这时两个对象再进行==判定，就会返回false。