Java謎題：等於，還是不等於？

等於還是不等於？

先來看下面的一段代碼： 

   代碼片段1

1. public static void main(final String[] args) {  
2.     Integer a = new Integer(100);  
3.     Integer b = 100;  
4.     System.out.println(a == b);   
5. }   

 這段代碼的輸出是什麼？相信很多人都會很容易的猜到：false，因爲a、b兩個對象的地址不同，用“==”比較時是false。恭喜你，答對了。

 再看下面的一段代碼：

     代碼片段2

1. public static void main(final String[] args) {  
2.     Integer a = 100;  
3.     Integer b = 100;  
4.     System.out.println(a == b);   
5. }  

 你可能會回答，這沒什麼不一樣啊，所以還是false。很遺憾，如果你執行上面的一段代碼，結果是true。

 上面的代碼可能讓你有些意外，那好吧，再看看下面的這段代碼：

     代碼片段3

1. public static void main(final String[] args) {  
2.     Integer a = 156;  
3.     Integer b = 156;  
4.     System.out.println(a == b);   
5. }  

 結果是true嗎？很遺憾，如果你執行上面的一段代碼，結果是false。

  感到吃驚嗎？那最後再看下面的一段代碼：

     代碼片段4

1. public static void main(final String[] args) {  
2.     Integer a = Integer.valueOf(100);  
3.     Integer b = 100;  
4.     System.out.println(a == b);   
5. }  

最後的結果，可能你已經猜到了，是true。

爲什麼會這樣？

現在我們分析一下上面的代碼。可以很容易的看出，這一系列代碼的最終目的都是用“==”對兩個對象進行比較。Java中，如果用“==”比較兩個對象結果爲true，說明這兩個對象實際上是同一個對象，false說明是兩個對象。 

現在，我們來看看爲什麼會出現上面的現象。 

我們先看代碼片段4：最後的運行結果是true，說明a、b兩個對象實際上是同一個對象。但是a對象是通過調用Integer的valueOf方法創建的，而b對象是通過自動裝箱創建出來的，怎麼會是同一個對象呢？難道問題在字節碼那裏，畢竟Java程序是依靠虛擬器運行字節碼來實現的。 

通過jdk中自帶的工具javap，解析字節碼，核心的部分摘取如下：

1. 0:  bipush  100  
2. 2:  invokestatic    #16; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;  
3. 5:  astore_1  
4. 6:  bipush  100  
5. 8:  invokestatic    #16; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;  

代碼中我們只調用了一次Integer.valueOf方法，但是字節碼中出現了兩次對Integer.valueOf方法的調用。那麼另一次是哪裏呢？只可能在自動裝箱時調用的。因此這段代碼實際上等價於：

1. public static void main(final String[] args) {  
2.     Integer a = Integer.valueOf(100);  
3.     Integer b = Integer.valueOf(100);  
4.     System.out.println(a == b);   
5. }  

 現在問題就簡單了：看jdk源代碼，查看valueOf方法的具體實現：

1. public static Integer valueOf(int i) {  
2.     final int offset = 128;  
3.     if (i >= -128 && i <= 127) { // must cache   
4.         return IntegerCache.cache[i + offset];  
5.     }  
6.     return new Integer(i);  
7. }  

 看到這兒，上面的代碼就很明確了：對於-128到127的數字，valueOf返回的是緩存中的對象。所以兩次調用Integer.valueOf(100)返回的都是同一個對象。

我們再先看代碼片段3：根據上面的分析，代碼片段3實際上等價於以下代碼：

1. public static void main(final String[] args) {  
2.     Integer a = Integer.valueOf(156);  
3.     Integer b = Integer.valueOf(156);  
4.     System.out.println(a == b);   
5. }  

 由於156不在-128到127範圍內，所以兩個對象都是通過new Integer()的方式創建的，所以最後結果爲false。 

 片段1和片段2就不做具體分析了，相信讀者可以自行分析。

  最後，請大家思考一下問題：通過上面的分析，瞭解到整數的自動裝箱是通過Integer.valueOf(int number)實現的，那麼自動拆箱是如何實現的呢？

原文鏈接：http://www.blogjava.net/todayx-org/archive/2012/02/01/369115.html