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类型的==比较出现问题的原理已经讲完，希望对你有所帮助。