先看一個現象：
下面代碼會輸出什么？
Integer a = 127;
Integer b = 127;
System.out.println(a==b);
Integer c = 128;
Integer d = 128;
System.out.println(c==d);
Long e = 127l;
Long f = 127l;
System.out.println(e==f);
Long g = 128l;
Long h = 128l;
System.out.println(g==h);
運行結果：
true
false
true
false
為什么？
原因有兩個：java中裝箱和拆箱的真相，以及Integer、Long、Short、Byte類型對應valueOf()方法中使用的緩存。
1、java中的裝箱和拆箱的真相
在介紹java中的裝箱和拆箱的真相之前，先說一下java中的語法糖：
在java中提供了一些語法糖，語法糖是一種語法，它可以方便開發者的使用，避免出現一些錯誤，但是對java編譯運行的性能并沒有太大的提升。
其中基本類型中的裝箱拆箱就是java提供的一種語法糖。
語法糖在javac對java源碼進行編譯時會被解除，用正常的java語法代替。關于javac的過程可以參考我的博客《javac命令的使用和運作原理》。
通過javap查看上面這段代碼的反匯編指令（也可以使用gui等反編譯工具查看class飯編譯的java代碼）,由于反匯編指令過多，這里只貼出前面Integer復制的四個操作部分的反匯編指令代碼：
Code:
stack=3, locals=9, args_size=1
0: bipush 127
//所謂的裝箱操作，無法是調用了對于類的valueOf（）方法
2: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
5: astore_1
6: bipush 127
8: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
11: astore_2
12: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
15: aload_1
16: aload_2
17: if_acmpne 24
20: iconst_1
21: goto 25
24: iconst_0
25: invokevirtual #4 // Method java/io/PrintStream.println:(Z)V
28: sipush 128
31: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
34: astore_3
35: sipush 128
38: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
通過上面的反匯編指令，可以看出：
Integer a = 127;
在編譯后，實際上被替換成了：
Integer a = Integer.valueOf(127);
實際上，java中基本類型的裝箱操作，都是調用了對應引用類型的ValueOf(x)方法。
比如：
Long e = 127l;
實際上等同于
Long e = Long.valueOf(127l);
而同樣的，拆箱操作，都是調用了對應引用類型對象的xxxValue()方法。
比如：
Long d = 128l;
此時d是一個Long類型的對象。
long dd = d;
拆箱的操作，其實編譯后，等于：
long dd = d.longValue();
通過對java中拆箱和裝箱真相的描述，我們知道了，一起開始例子中
Integer a = 128;
實際上等于
Integer a = Integer.valueOf(128);
而
Long h = 128l;
實際上等同于
Long h = Long.valueOf(128l);
2、Integer、Long、Short、Byte類型對應valueOf()方法中使用的緩存
查看一下Integer.valueOf()的源碼：
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
//IntegerCache.low值為-128，IntegerCache.high值為127
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
看到這，一切就明了了，在Integer中調用其valueOf(x)方法時，如果x值在-128到127之間，那么就會存緩存中獲得Integer對象，也就是說：
Integer a = 127;
Integer b = 127;
變量a和變量b存取的值都是127這個值在IntegerCache.cache中緩存的對象的地址引用。
自然a==b，就是true了。
再者
Integer c = 128;
Integer d = 128;
由于128不在緩存內，會創建一個Integer對象：
new Integer(i);
也就是說c和d存放的值，是兩個不同對象的地址引用。
自然c==d,就是false了。
你也可以通過配置jvm啟動參數，來修改cache的上限：
-D java.lang.Integer.IntegerCache.high=XXX
比如指定200，則會默認緩存-128~200的整數值。
不僅Integer如此，Long、Short、Byte這三種類型，在調用其valueOf()時也會走緩存，而且都是-128~127之間。
比如：Long.valueOf()的源碼如下：
public static Long valueOf(String s) throws NumberFormatException
{
return Long.valueOf(parseLong(s, 10));
}
public static Long valueOf(long l) {
final int offset = 128;
if (l >= -128 && l <= 127) { // will cache
return LongCache.cache[(int)l + offset];
}
return new Long(l);
}
至此，Integer、Long、Short、Byte類型的==比較出現問題的原理已經講完，希望對你有所幫助。
