java中的自动装箱与拆箱陷阱

2017-04-20 14:43 Posted in Learn with Java

自动装箱(boxing)与拆箱(unboxing)是java5引入的一个新机制，那么什么是自动装箱与拆箱呢？

由于java是一个几乎纯洁的面向对象语言，这里的几乎是说java为了编程的方便，还是引入了8种基本数据类型，但为了保持面向对象的特性，java为每一种基本数据类型都引入了对应的包装类(wrapper class)，它们之间的对应关系如下表所示：

boolean	byte	char	int	short	long	float	double
Boolean	Byte	Character	Integer	Short	Long	Float	Double

自动装箱与拆箱就是指基本数据类型与对应的包装类之间可以互相转换，而不需要程序员进行手动转换。然而，这其中有些地方值得注意，请看如下代码：

public class IntegerBoxingUnboxing
{
    public static void main(String[] args)
    {
        Integer i1 = new Integer(3);
        Integer i2 = 3;
        int i3 = 5;
        Integer i4 = 5;
        
        System.out.println(i1 == i2); //false
        System.out.println(i3 == i4); //true
    }
}

第一个输出false是因为i1与i2是两个不同的Integer对象，由于指向不同的内存区域，所以比较结果为false
第二个输出true是因为在进行i3与i4之间的比较的时候，虚拟机会将i4自动拆箱为int类型，由于值相同，所以结果为true

再看如下例子：

public class IntegerBoxingUnboxing
{
    public static void main(String[] args)
    {
        Integer i1 = 100, i2 = 100, i3 = 150, i4 = 150;
        System.out.println(i1 == i2); //true
        System.out.println(i3 == i4); //false
    }
}

这样的输出结果似乎违反直觉，难道i1,i2,i3,i4之间的比较不是对象间的比较么？i1和i2又不是相同对象，为什么结果是true呢？

事实上，i1和i2还真就是同一个对象！

当我们给一个Integer对象赋值的时候，其内部调用了Integer的静态方法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是Integer的内部类，其代码如下所示：

* Cache to support the object identity semantics of autoboxing for values between
* -128 and 127 (inclusive) as required by JLS.
*
* The cache is initialized on first usage.  The size of the cache
* may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
* During VM initialization, java.lang.Integer.IntegerCache.high property
* may be set and saved in the private system properties in the
* sun.misc.VM class.
*/

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对象的值在-128到127之间，它就不会new一个新对象，而是直接引用IntegerCache中的对象。这就是为什么i1与i2的比较结果为true的原因：根本就是同一个对象的引用而已。

BlueBreeze

Blog

java中的自动装箱与拆箱陷阱