深入剖析Java中的裝箱和拆箱，

深入剖析Java中的裝箱和拆箱，
裝箱

在Java SE5之前，如果要產生一個數值為10的Integer對象，必須這樣進行：

Integer i = new Integer(10);

 

而在從Java SE5開始就提供了自動裝箱的特性，如果要產生一個數值為10的Integer對象，只需要這樣就可以了：

Integer i = 10;

這個過程中會自動根據數值建立對應的 Integer對象，這就是裝箱。

 

拆箱

那什麼是拆箱呢？顧名思義，跟裝箱對應，就是自動將封裝器類型轉換為基礎資料型別 (Elementary Data Type)：

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

 

簡單一點說，裝箱就是  自動將基礎資料型別 (Elementary Data Type)轉換為封裝器類型；拆箱就是  自動將封裝器類型轉換為基礎資料型別 (Elementary Data Type)。

 

　下表是基礎資料型別 (Elementary Data Type)對應的封裝器類型：

int（4位元組）	Integer
byte（1位元組）	Byte
short（2位元組）	Short
long（8位元組）	Long
float（4位元組）	Float
double（8位元組）	Double
char（2位元組）	Character
boolean（未定）	Boolean

 裝箱和拆箱是如何?的我們就以Interger類為例，下面看一段代碼：

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

 

　　反編譯class檔案之後得到如下內容：

　　

　　從反編譯得到的位元組碼內容可以看出，在裝箱的時候自動調用的是Integer的valueOf(int)方法。而在拆箱的時候自動調用的是Integer的intValue方法。

　　其他的也類似，比如Double、Character。

　　因此可以用一句話總結裝箱和拆箱的實現過程：

　　裝箱過程是通過調用封裝器的valueOf方法實現的，而拆箱過程是通過調用封裝器的 xxxValue方法實現的。（xxx代表對應的基礎資料型別 (Elementary Data Type)）。

 面試中相關的問題

　　雖然大多數人對裝箱和拆箱的概念都清楚，但是在面試和筆試中遇到了與裝箱和拆箱的問題卻不一定會答得上來。下面列舉一些常見的與裝箱/拆箱有關的面試題。

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);    }}

 

　　也許有些朋友會說都會輸出false，或者也有朋友會說都會輸出true。但是事實上輸出結果是：

truefalseView Code

 

 　　為什麼會出現這樣的結果？輸出結果表明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() {}    }

 

　　從這2段代碼可以看出，在通過valueOf方法建立Integer對象的時候，如果數值在[-128,127]之間，便返回指向IntegerCache.cache中已經存在的對象的引用；否則建立一個新的Integer對象。

　　上面的代碼中i1和i2的數值為100，因此會直接從cache中取已經存在的對象，所以i1和i2指向的是同一個對象，而i3和i4則是分別指向不同的對象。

2.下面這段代碼的輸出結果是什嗎？

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

 

　　也許有的朋友會認為跟上面一道題目的輸出結果相同，但是事實上卻不是。實際輸出結果為：

falsefalseView Code

 

　　至於具體為什麼，讀者可以去查看Double類的valueOf的實現。

　　在這裡只解釋一下為什麼Double類的valueOf方法會採用與Integer類的valueOf方法不同的實現。很簡單：在某個範圍內的整型數值的個數是有限的，而浮點數卻不是。

　　注意，Integer、Short、Byte、Character、Long這幾個類的valueOf方法的實現是類似的。

　　　　　Double、Float的valueOf方法的實現是類似的。

3.下面這段代碼輸出結果是什麼：

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

 

　　輸出結果是：

truetrueView Code

 

　　至於為什麼是這個結果，同樣地，看了Boolean類的源碼也會一目瞭然。下面是Boolean的valueOf方法的具體實現：

public static Boolean valueOf(boolean b) {        return (b ? TRUE : FALSE);    }

 

而其中的 TRUE 和FALSE又是什麼呢？在Boolean中定義了2個靜態成員屬性：

public static final Boolean TRUE = new Boolean(true);    /**      * The <code>Boolean</code> object corresponding to the primitive      * value <code>false</code>.      */    public static final Boolean FALSE = new Boolean(false);

 

　　至此，大家應該明白了為何上面輸出的結果都是true了。

4.談談Integer i = new Integer(xxx)和Integer i =xxx;這兩種方式的區別。

　　當然，這個題目屬於比較寬泛類型的。但是要點一定要答上，我總結一下主要有以下這兩點區別：

　　1）第一種方式不會觸發自動裝箱的過程；而第二種方式會觸發；

　　2）在執行效率和資源佔用上的區別。第二種方式的執行效率和資源佔用在一般性情況下要優於第一種情況（注意這並不是絕對的）。

5.下面程式的輸出結果是什嗎？

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));    }}

 

　　先別看輸出結果，讀者自己想一下這段代碼的輸出結果是什麼。這裡面需要注意的是：當 "=="運算子的兩個運算元都是 封裝器類型的引用，則是比較指向的是否是同一個對象，而如果其中有一個運算元是運算式（即包含算術運算）則比較的是數值（即會觸發自動拆箱的過程）。另外，對於封裝器類型，equals方法並不會進行類型轉換。明白了這2點之後，上面的輸出結果便一目瞭然：

truefalsetruetruetruefalsetrueView Code

 

　　第一個和第二個輸出結果沒有什麼疑問。第三句由於  a+b包含了算術運算，因此會觸發自動拆箱過程（會調用intValue方法），因此它們比較的是數值是否相等。而對於c.equals(a+b)會先觸發自動拆箱過程，再觸發自動裝箱過程，也就是說a+b，會先各自調用intValue方法，得到了加法運算後的數值之後，便調用Integer.valueOf方法，再進行equals比較。同理對於後面的也是這樣，不過要注意倒數第二個和最後一個輸出的結果（如果數值是int類型的，裝箱程序呼叫的是Integer.valueOf；如果是long類型的，裝箱調用的Long.valueOf方法）。

 

原文出處：http://www.cnblogs.com/dolphin0520/p/3780005.html