自動裝箱和拆箱問題是Java中一個老生常談的問題了，今天我們就來一些看一下裝箱和拆箱中的若干問題。本文先講述裝箱和拆箱最基本的東西，再來看一下面試筆試中經常遇到的與裝箱、拆箱相關的問題。

　　以下是本文的目錄大綱：

1. 　   什麼是裝箱？什麼是拆箱？
2.        為什麼需要裝箱和拆箱
3. 　　裝箱和拆箱是如何實現的
4. 　　面試中相關的問題

一.什麼是裝箱？什麼是拆箱？

     Java為每種基本資料型別都提供了對應的包裝器型別，在Java SE5之前，如果要生成一個數值為10的Integer物件，必須這樣進行：

Integer i = new Integer(10);

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

Integer i = 10;

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

   拆箱：顧名思義，跟裝箱對應，就是自動將包裝器型別轉換為基本資料型別

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

  簡單一點說，裝箱就是  自動將基本資料型別轉換為包裝器型別；拆箱就是  自動將包裝器型別轉換為基本資料型別。

下表是基本資料型別對應的包裝器型別：

二、為什麼需要裝箱與拆箱？

        java早年設計的一個缺陷，基本資料型別不是物件，自然不是Object的子類，需要裝箱才能把資料型別變成一個類，那就可以把裝箱過後的基本資料型別當做一個物件，就可以呼叫object子類的介面。而且基本資料型別是不可以作為形參使用的，裝箱後就可以。而且在jdk1.5之後就實現了自動裝箱拆箱，包裝資料型別具有許多基本資料型別不具有的功能，只是裝箱拆箱過程會稍稍微的影響一下效率

三、裝箱和拆箱是如何實現的

      我們就以Interger類為例，下面看一段程式碼：

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

      反編譯class檔案之後得到如下內容：命令（javap -c Main）

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

　　其他的也類似，比如Double、Character，不相信的朋友可以自己手動嘗試一下。

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

　　裝箱過程是通過呼叫包裝器的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);
    }
}

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

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

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

至於具體為什麼，讀者可以去檢視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);
    }
}

     至於為什麼是這個結果，同樣地，看了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點之後，上面的輸出結果便一目瞭然：

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

如果對上面的具體執行過程有疑問，可以嘗試獲取反編譯的位元組碼內容進行檢視。