呐，码农呢，还是要多看点源码，喏->....
Long & long装箱拆箱问题
今日看到某公众号，发表的一篇Java基础文章, 其中有讲到Java包装类拆箱，装箱问题， 如下：
Long l1 = 128L;
Long l2 = 128L;
System.out.println(l1 == l2); // 1
System.out.println(l1 == 128L); // 2
Long l3 = 127L;
Long l4 = 127L;
System.out.println(l3 == l4); // 3
System.out.println(l3 == 127L); // 4答：对于注释1的语句，Long包装类型常量cache为-128到127之间，所以l1和l2变量是两个对象，==比较的是对象的地址，所以打印为false。
对于注释2的语句，由于包装类型在表达式中且表达式中至少有一个不是包装类型，所以Longl1==128L中l1自动拆箱退化为基本类型比较，所以数值比较为true。
对于注释3的语句，Long包装类型-128到127之间的值维护在一个常量池中，所以l3和l4引用同一个对象，故打印true。
对于注释4的语句类似注释2语句，所以打印为true。
无知蒙蔽我的眼
我知道基本数据类型有对应的包装类型， 装箱无非是调用 valueOf(long l) 之类的方法，拆箱无非是xxxValue()方法。 但是，这个 -128 ~ 127 是怎么搞出来的，没细想，还在对应的群里去询问，得到的回复有说，直接去看源码，或者有提到与字节bit相关。我还sblj的跟他们讨论，这个个问题。越想越不对，还是直接看源码吧。
查看源码
看到源码，装箱方法，valueOf(long l) 就秒懂了。想骂人~~
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);
}再看看LongCache 是什么。
private static class LongCache {
private LongCache(){}
static final Long cache[] = new Long[-(-128) + 127 + 1];
static {
for(int i = 0; i < cache.length; i++)
cache[i] = new Long(i - 128);
}
}原来这里还用到了 cache[-128 ~ 127] 256个final的 Long实例。导致只要在 -128 ~ 127之前的整形数字，装箱为Long型的时候，其实他们是同一个引用！所以，就出现了如上的答案，还是要多看源码，不要想当然。
一点思考
既然，看到这些，那就发散一下，csdn 2014年就有人提到，并分析了该问题。
链接如下：JAVA中Long与Integer比较容易犯的错误
其他基本类型是否也是一样的呢？
Byte, Integer, Short, Character, Float, Double
Byte
private static class ByteCache {
private ByteCache(){}
static final Byte cache[] = new Byte[-(-128) + 127 + 1];
static {
for(int i = 0; i < cache.length; i++)
cache[i] = new Byte((byte)(i - 128));
}
}Integer
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
try {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
} catch( NumberFormatException nfe) {
// If the property cannot be parsed into an int, ignore it.
}
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
// range [-128, 127] must be interned (JLS7 5.1.7)
assert IntegerCache.high >= 127;
}
private IntegerCache() {}
}Short
private static class ShortCache {
private ShortCache(){}
static final Short cache[] = new Short[-(-128) + 127 + 1];
static {
for(int i = 0; i < cache.length; i++)
cache[i] = new Short((short)(i - 128));
}
}Character 缓存数组长度是128
private static class CharacterCache {
private CharacterCache(){}
static final Character cache[] = new Character[127 + 1];
static {
for (int i = 0; i < cache.length; i++)
cache[i] = new Character((char)i);
}
}Float, Double
有关他们2个包装类，是没有cache数组的，说明按照文章开始的题目而言，2个Float，Double使用 “==” 结果是false 。
Float.equal(), Double.equal() 他们的结果是比较数值， 他们会转化为对应的int， long基本类型
@Float.java
public static int floatToIntBits(float value) {
int result = floatToRawIntBits(value);
// Check for NaN based on values of bit fields, maximum
// exponent and nonzero significand.
if ( ((result & FloatConsts.EXP_BIT_MASK) ==
FloatConsts.EXP_BIT_MASK) &&
(result & FloatConsts.SIGNIF_BIT_MASK) != 0)
result = 0x7fc00000;
return result;
}@Double.java
public static long doubleToLongBits(double value) {
long result = doubleToRawLongBits(value);
// Check for NaN based on values of bit fields, maximum
// exponent and nonzero significand.
if ( ((result & DoubleConsts.EXP_BIT_MASK) ==
DoubleConsts.EXP_BIT_MASK) &&
(result & DoubleConsts.SIGNIF_BIT_MASK) != 0L)
result = 0x7ff8000000000000L;
return result;
}如何更好的编写代码？
现代的IDE有很强大的提示功能， 如上 l1 == l2 这样的代码 IDE就会提示 他们永远是false的。所以，在我么编写代码中，需要明确，你是干什么用，要是比较包装类大小，应该考虑直接使用 XXX.equal(XXX)，而不应该是 ==
祝，春安！
2018年3月24日