Java中的自动装箱与拆箱机制剖析

一.什么是装箱？什么是拆箱？

• 装箱：将基本类型用他们的引用类型包装起来
• 拆箱：将包装类型转换为基本数据类型

在Java SE5之前，如果要生成一个数值为10的Integer对象，必须这样进行

Integer i = new Integer(10);

而在从Java SE5开始就提供了自动装箱的特性，如果要生成一个数值为10的Integer对象，只需要这样就可以了：

Integer i = 10;

这个过程中会自动根据数值创建对应的 Integer对象，这就是装箱。

跟装箱对应，就是自动将包装器类型转换为基本数据类型

Integer i = 10;  //装箱
int n = i;   //拆箱

基本数据类型对应的包装器类型总结：

 

二.装箱和拆箱的实现

以这段代码为例

public class Main {
    public static void main(String[] args) {
        Integer i = 10;
        int n = i;
    }
}

 反编译class文件之后得到如下内容：

从反编译得到的字节码内容可以看出，在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法 。

总结：装箱过程是通过调用包装器的valueOf方法实现的，而拆箱过程是通过调用包装器的 xxxValue方法实现的。（xxx代表对应的基本数据类型）。

三.相关问题分析

1.下面这段代码的输出结果是什么？

public class Main {
    public static void main(String[] args) {
         
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

输出结果： 

true
false

输出结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。 

查看Integer的valueOf方法的具体实现源码：

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

其中IntegerCache类的实现为源码：

private static class IntegerCache {
        static final int high;
        static final Integer cache[];

        static {
            final int low = -128;

            // high value may be configured by property
            int h = 127;
            if (integerCacheHighPropValue != null) {
                // Use Long.decode here to avoid invoking methods that
                // require Integer's autoboxing cache to be initialized
                int i = Long.decode(integerCacheHighPropValue).intValue();
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - -low);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
}

通过分析上述源码可以看出，在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。

结果分析：

1. 上面的代码中i1和i2的数值为100，因此会直接从cache中取已经存在的对象，所以i1和i2指向的是同一个对象。
2. i3和i4则是分别指向不同的对象。 

2.下面这段代码的输出结果是什么？ 

public class Main {
    public static void main(String[] args) {
         
        Integer a = 1;
        Integer b = 2;
        Integer c = 3;
        Integer d = 3;
        Integer e = 321;
        Integer f = 321;
        Long g = 3L;
        Long h = 2L;
         
        System.out.println(c==d);
        System.out.println(e==f);
        System.out.println(c==(a+b));
        System.out.println(c.equals(a+b));
        System.out.println(g==(a+b));
        System.out.println(g.equals(a+b));
        System.out.println(g.equals(a+h));
    }
}

 输出结果：

true
false
true
true
true
false
true

 注意：当 "=="运算符的两个操作数都是 包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。

 结果分析：

1. 第一个和第二个输出结果没有什么疑问。
2. 第三句由于  a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），因此它们比较的是数值是否相等。
3. 第四句对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。
4. 第五、六、七句同理

注：倒数第二个和最后一个输出的结果（如果数值是int类型的，装箱过程调用的是Integer.valueOf；如果是long类型的，装箱调用的Long.valueOf方法）。