第49期 面试官：为什么Integer用==比较时127相等而128不相等？
关注公众号“面试专栏”，回复面试，获取优质面试资源。
本篇是1000期面试系列文章的第49篇，持续更新中.....欢迎关注。
前言
这个几乎是Java 5引入自动装箱和自动拆箱后，很多人都会遇到（而且不止一次），而又完全摸不着头脑的坑。虽然已有很多文章分析了原因，但鉴于我这次还差点坑了同学，还是记录下来长点记性。
例一
来个简单点的例子:
public static void main(String[] args) {
for (int i = 0; i < 150; i++) {
Integer a = i;
Integer b = i;
System.out.println(i + " " + (a == b));
}
}
i取值从0到150，每次循环a与b的数值均相等，输出a == b。运行结果：
0 true
1 true
2 true
3 true
...
126 true
127 true
128 false
129 false
130 false
...
从128开始a和b就不再相等了。
这个例子还容易看出来涉及到int的自动装箱和自动拆箱，下面来个不太容易看出来的。
例二
public static void main(String[] args) {
Map<Integer, Integer> mapA = new HashMap<>();
Map<Integer, Integer> mapB = new HashMap<>();
for (int i = 0; i < 150; i++) {
mapA.put(i, i);
mapB.put(i, i);
}
for (int i = 0; i < 150; i++) {
System.out.println(i + " " + (mapA.get(i) == mapB.get(i)));
}
}
i取值从0到150，mapA和mapB均存储(i, i)数值对，输出mapA的值与mapB的值的比较结果。
运行结果：
0 true
1 true
2 true
3 true
...
126 true
127 true
128 false
129 false
130 false
...
为什么两个例子都是从0到127均显示两个变量相等，而从128开始不相等？
原因分析
自动装箱
首先回顾一下自动装箱。对于下面这行代码
Integer a = 1;
变量a为Integer类型，而1为int类型，且Integer和int之间并无继承关系，按照Java的一般处理方法，这行代码应该报错。
但因为自动装箱机制的存在，在为Integer类型的变量赋int类型值时，Java会自动将int类型转换为Integer类型，即:
Integer a = Integer.valueOf(1);
valueOf()方法返回一个Integer类型值，并将其赋值给变量a。这就是int的自动装箱。
是同一个对象吗？
再看最开始的例子：
public static void main(String[] args) {
for (int i = 0; i < 150; i++) {
Integer a = i;
Integer b = i;
System.out.println(i + " " + (a == b));
}
}
每次循环时，Integer a = i和Integer b = i都会触发自动装箱，而自动装箱会将int转换Integer类型值并返回；我们知道Java中两个new出来的对象，因为是不同的实例，无论如何==都会返回fasle。
比如:
new Integer(1) == new Integer(1);
就会返回false。
那么例子中Integer a = i和Integer b = i自动装箱产生的变量a和b就不应该是同一个对象了，那么==的结果应该是false。
128以上为false容易理解，但为何0到127时返回true了呢？
==返回true的唯一情况是比较的两个对象为同一个对象，那不妨把例子中a和b的内存地址都打印出来看看：
for(int i=0;i<150;i++){
Integer a=i;
Integer b=i;
System.out.println(a+" "+b+" "+System.identityHashCode(a)+" "+System.identityHashCode(b));
}
identityHashCode()方法可以理解为输出对应变量的内存地址，输出为：
0 0 762119098 762119098
1 1 1278349992 1278349992
2 2 1801910956 1801910956
3 3 1468253089 1468253089
...
126 126 1605164995 1605164995
127 127 1318497351 1318497351
128 128 101224864 479240824
129 129 1373088356 636728630
130 130 587071409 1369296745
...
竟然从0到127不同时候自动装箱得到的是同一个对象！从128开始才是正常情况。
Integer核心源码分析
“从0到127不同时候自动装箱得到的是同一个对象”就只能有一种解释：自动装箱并不一定new出新的对象。
既然自动装箱涉及到的方法是Integer.valueOf()，不妨看看其源代码：
/**
* Returns an {@code Integer} instance representing the specified
* {@code int} value. If a new {@code Integer} instance is not
* required, this method should generally be used in preference to
* the constructor {@link #Integer(int)}, as this method is likely
* to yield significantly better space and time performance by
* caching frequently requested values.
*
* This method will always cache values in the range -128 to 127,
* inclusive, and may cache other values outside of this range.
*
* @param i an {@code int} value.
* @return an {@code Integer} instance representing {@code i}.
* @since 1.5
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
其注释里就直接说明了-128到127之间的值都是直接从缓存中取出的。看看是怎么实现的：如果int型参数i在IntegerCache.low和IntegerCache.high范围内，则直接由IntegerCache返回；否则new一个新的对象返回。似乎IntegerCache.low就是-128，IntegerCache.high就是127了。
看看IntegerCache的源码：
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() {}
}
果然在其static块中就一次性生成了-128到127直接的Integer类型变量存储在cache[]中，对于-128到127之间的int类型，返回的都是同一个Integer类型对象。
这下真相大白了，整个工作过程就是：Integer.class在装载（Java虚拟机启动）时，其内部类型IntegerCache的static块即开始执行，实例化并暂存数值在-128到127之间的Integer类型对象。当自动装箱int型值在-128到127之间时，即直接返回IntegerCache中暂存的Integer类型对象。
为什么Java这么设计？
我想是出于效率考虑，因为自动装箱经常遇到，尤其是小数值的自动装箱；而如果每次自动装箱都触发new，在堆中分配内存，就显得太慢了；所以不如预先将那些常用的值提前生成好，自动装箱时直接拿出来返回。哪些值是常用的？就是-128到127了。
解决方法
既然我们的目的是比较数值是否相等，而非判断是否为同一对象；而自动装箱又不能保证同一数值的Integer一定是同一对象或一定不是同一对象，那么就不要用==，直接用equals()好了。实际上，Integer重写了equals()方法，直接比较对象的数值是否相等。
public boolean equals(Object obj) {
if (obj instanceof Integer) {
//转换成int类型进行比较
//所以比较的是基本数据类型的值
return value == ((Integer)obj).intValue();
}
return false;
}
下面的案例，就不在出现false了。
for (int i = 0; i < 150; i++) {
Integer a = i;
Integer b = i;
System.out.println(i + " " + (a.equals(b)));
}
这样返回值就全都是true了。
PS：除了int类型的封装类Integer以外，其他基本数据类型的封装类中也都有使用cache，有兴趣的可以去看看。
来源：http://ccx4.cn/EUoaj
精彩推荐