java中Integer、Long、Short、Byte类型的=
先看一个现象：
下面代码会输出什么？
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了。
不仅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类型的==比较出现问题的原理已经讲完，希望对你有所帮助。
