实际开发中，我们使用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。
image
该类只有一些抽象方法XXXValue。如下图所示。
image 注析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);
以上代码你认为输出什么？
<details>
<summary>答案</summary>
<pre>
<code>
false
true
true
true
false
true
</code>
</pre>
</details>
觉得好？关注微信公众号:技术之禅（微信号"zen_of_java"）获取更多干货和资源！
公众号回复"java","spring","javascript","python","english"等获取福利。
