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了。
你也可以通过配置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);
}

转载：https://www.jianshu.com/p/e0582ac8ba3d,感谢!