关于Integer m经过 m--运算后的问题

Question

今天看到了一个别人的提问，想起来一个问题来希望大家帮忙解决一下
Integer m = new Integer(2); 
Integer n = new Integer("2"); 
System.out.println(m==n); 
System.out.println(m.equals(n)); 
结果为：false true m--;      //是不是经过运算对象m,n都指向同一个‘1’地址的引用了。具体原理是什么？怎么变化的？希望大家指导一下！
n--; System.out.println(m==n); 
System.out.println(m.equals(n));
结果为true true;

Answer 1

public static Integer valueOf(int i) { 
    final int offset = 128; 
    if (i >= -128 && i <= 127) { // must cache 
      return IntegerCache.cache[i + offset]; 
    } 
    return new Integer(i); 
} 

Answer 2

先来解释一下
Integer m = new Integer(2);
Integer n = new Integer("2");
m--;
n--;
Integer 类的构造方法源代码如下：
    private final int value;  //用于保存被包装进Integer对象中的整数    public Integer(int value) {
this.value = value;
    }    public Integer(String s) throws NumberFormatException {
this.value = parseInt(s, 10);  //用字符串解析成的整数初始化value
    }    public int intValue() {
return value;
    }前两行分别创建了两个包装有整数2的Integer对象并分别交给m,n引用着。
后两行使用了自动包装和自动解包机制（也叫自动装箱自动拆箱，英文原术语应该是autowrapping），
这里 m-- 和 n-- 相当于：int tm = m.intValue();
tm--;
m = new Integer(tm);
int tn = n.intValue();
tn--;
n = new Integer(tn);但要注意，这里只是相当于，按照自动打包规范描述，当自动包装发生时为了优化性能，对于在-128~127之间的int类型整数值会被包装到相同的对象中，可以用下面代码验证：public class AutoWrapping { public static void main(String[] args) {
Integer i = 100;
Integer j = 100;
System.out.println(i == j);
Integer m = 129;
Integer n = 129;
System.out.println(m == n);
}
}输出是 true false。
而上面 m-- 和 n-- 执行时就是这种情况。
各位应该明白了吧！

Answer 3

感谢sagezk 您的解释很透彻！谢谢您的回答！

Answer 4

更正一下：m-- 和 n-- 相当于： int tm = m.intValue();
tm--;
m = Integer.valueOf(tm);
int tn = n.intValue();
tn--;
n = Integer.valueOf(tn);再结合：    public static Integer valueOf(int i) {
final int offset = 128;
if (i >= -128 && i <= 127) { // must cache 
    return IntegerCache.cache[i + offset];  //缓存处理
}
        return new Integer(i);
    }

Answer 5

  return IntegerCache.cache[i + offset];
//这句代码不是十分明白楼上能否详细说明一下！

Answer 6

 return IntegerCache.cache[i + offset];  //缓存处理
这句代码不是很明白能否详细说明一下

Answer 7

    private static class IntegerCache {
private IntegerCache(){} static final Integer cache[] = new Integer[-(-128) + 127 + 1]; static {
    for(int i = 0; i < cache.length; i++)
cache[i] = new Integer(i - 128);
}
    }
IntegerCache 是一个内部类，除了静态块外只有一个公有静态 Integer 数组 cache，其中每个元素引用着 Integer(-128) 到 Integer(127) 之间的一个Integer对象，return IntegerCache.cache[i + offset]; 的作用是从中找到与 valueOf(int i) 中参数 i 对应的 Integer 对象并返回它的引用。