你真的了解Java中的Long嘛？

实际开发中，我们使用Long类型的情景应该是非常多的。可是，你真的完全掌握了Long类型嘛？

测试代码

首先，我们来看一段测试代码。该段代码可以通过测试。

    @Test
    public void testLong() {
        long primaryLong = 127L;
        Long long1 = Long.valueOf(primaryLong);
        Long long2 = 127L;

        Assert.assertTrue(long1 == long2); // 1

        long1 = new Long(127L);
        Assert.assertFalse(long1 == long2); // 2

        primaryLong = 128L;
        long1 = Long.valueOf(primaryLong);
        long2 = 128L;

        Assert.assertFalse(long1 == long2);  // 3

        long1 = new Long(128L);
        Assert.assertFalse(long1 == long2);  // 4
    }
复制代码

上述测试代码中，我们比较了2个Long类型的变量long1和long2之间是否相等，这里我们用了“==”操作符，用来测试2个变量所引用的地址是否相等。

资深码农应该都创建Long类型有三种方法：new Long()、Long.valueOf()和自动装箱。上述代码分别演示了三种方式得到的结果。

代码注析1返回为true。这说明在使用值127L时，不管使用Long.valueOf赋值创建Long变量还是使用自动装箱将long转换为Long类型，2个变量都指向同一位置。
代码注析2返回为false。这说明使用new Long(127L)创建出的Long变量，跟刚才使用自动装箱创建的Long变量不再指向同一位置。
代码注析3、4都返回为false。这说明在使用值128L创建Long变量后，每次都指向不同的位置，不管是new Long、Long.valueOf还是自动装箱。

这是怎么回事？特别是对于Long.valueOf还是自动装箱这两种方法，居然在值为127L和128L的时候结果不一样？

要想彻底理解上述代码为什么是这样的结果，还得从源代码入手。

分析

我们打开java.lang.Long的源代码。其中，关键性代码如下。

public final class Long extends Number implements Comparable<Long> {
    private final long value; // 1

    private static class LongCache { // 2
        private LongCache(){} // 2.1

        static final Long cache[] = new Long[-(-128) + 127 + 1]; // 2.2

        static { // 2.3
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Long(i - 128);
        }
    }

    @Deprecated(since="9")
    public Long(long value) { // 3
        this.value = value;
    }

    @Deprecated(since="9")
    public Long(String s) throws NumberFormatException { // 4
        this.value = parseLong(s, 10);
    }

    public static Long valueOf(long l) { // 5
        final int offset = 128;
        if (l >= -128 && l <= 127) { // will cache
            return LongCache.cache[(int)l + offset];
        }
        return new Long(l);
    }
}
复制代码

Long类继承自Number基类，Number类为一个抽象类，代表数。下图展示了Integer、Long、Byte、Short、Float和Double都是继承自Number。

该类只有一些抽象方法XXXValue。如下图所示。
注析1代表Long内部实际上存储的还是一个变量value，用来存储long类型原始数据。
注析3、4则是Long的2个构造方法，2个方法都是对value进行赋值，不做其他处理。
我们来看注析2和5：注析2是一个内部静态类LongCache，从名字上看，该类应该是Long类型的缓存：
- 注析2.1表示LongCache有一个private构造方法，用来阻止对该类的实例化。private构造方法通常用在工具类或者单实例类中，例如常见的单例模式就需要private构造方法。
- 注析2.2表示该类有一个Long类型的数组cache，并且带static final修饰。该数组的大小为-(-128) + 127 + 1=256。
  带有final的数组一经初始化就不能再对其重新赋值，但是还是可以通过对下标的引用修改cache数组各元素的值。
- 注析2.3表示对cache进行初始化。下标0到256分别初始化为-128到128之间的值。
接下来看注析5，当参数l为-128到127之间的值时，直接返回的是LongCache内部cache数组中对应下标中的值。这里很巧妙的设置offset为128，从而将最小值-128的值的下标设置为(int)l + offset=0。对不属于[-128, 127]范围之类的值，则调用new Long返回。
同时，留意构造方法处的@Deprecated(since="9")注解，表示从JDK9开始，构造方法已经不被推荐使用。JDK文档中，推荐使用静态工厂方法Long.valueOf来构造Long对象，能够获得更好的时间和空间表现。

根据语法标准，自动封装实际上调用的就是Long.valueOf，而不是构造方法。

综上分析，对于[-128, 127]的值，不管使用Long.valueOf还是自动装箱，最终都是读取LongCache.cache的同一下标的值，故而“==”为真。其他情况，2各不同的变量“==”比较为false。

拓展

对于Short类，源代码中ShortCache类和valueOf方法的实现和Long类型一模一样。这里就不展开了。
对于Byte类，只能容纳-128到127之间的值。valueOf方法能够通过ShortCache.cache返回所有的值。
对于Float和Double类，没有所谓的FloatCache和DoubleCache，所以每次构建的都是新对象。
为避免上述代码中出现的“==”比较出现的结果差异性。建议对象之间的之间比较，我们使用equals或者将包装类拆装成原始类型再使用“==”比较，上述测试代码中，可以使用long1.longValue()或者+long1将Long转换为long再使用“==”比较

注意，+long1一定是确保了+long1不会返回null。否则会报NullPointerException。

这里给一个小小的测试，看看大家理解的如何？

Long long1 = new Long(100L);
Long long2 = 100L;
Long long3 = 100L;
Long long4 = 128L;
Long long5 = 128L;

System.out.println(long1 == long2);
System.out.println(+long1 == long2);

System.out.println(long2 == long3);
System.out.println(+long2 == long3);

System.out.println(long4 == long5);
System.out.println(+long4 == long5);
复制代码

以上代码你认为输出什么？

答案


false
true
true
true
false
true
复制代码

你真的了解Java中的Long嘛？

测试代码

分析

拓展

猜你喜欢