这是我们今天要讨论的话题，因为我觉得它非常的有趣。

如果你运行如下代码：

Integer a = 1000, b = 1000;  
System.out.println(a == b);//1

Integer c = 100, d = 100;  
System.out.println(c == d);//2

你会得到以下运行结果：

false
true

我们知道，如果两个引用指向同一个对象，那么==就成立；反之，如果两个引用指向的不是同一个对象，那么==就不成立，即便两个引用的内容是一样的。因此，结果就会出现false。

这是非常有趣的地方。如果你查看Integer.java类，你会找到IntegerCache.java这个内部私有类，它为-128到127之间的所有整数对象提供缓存。

这个东西为那些数值比较小的整数提供内部缓存，当进行如此声明时：

Integer c = 100;

它的内部就是这样的：

Integer i = Integer.valueOf(100);

如果我们观察valueOf()类函数，我们可以看到

public static Integer valueOf(int i) {
      if (i >= IntegerCache.low && i
          return IntegerCache.cache[i + (-IntegerCache.low)];
      return new Integer(i);
    }

如果值在 -128 到 127 之间，它就会返回该缓存的实例。

因此，

Integer c = 100, d = 100;

两者指向同样的对象。

这就是为什么这段代码的结果为true了：

System.out.println(c == d);

现在你可能会问，为什么会为-128到127之间的所有整数设置缓存？

这是因为在这个范围内的小数值整数在日常生活中的使用频率要比其它的大得多，多次使用相同的底层对象这一特性可以通过该设置进行有效的内存优化。你可以使用reflection API任意使用这个功能。

运行下面的这段 Java 代码，你就会明白它的神奇所在了。

public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {

      Class cache = Integer.class.getDeclaredClasses()[0]; //1
      Field myCache = cache.getDeclaredField("cache"); //2
      myCache.setAccessible(true);//3

      Integer[] newCache = (Integer[]) myCache.get(cache); //4
      newCache[132] = newCache[133]; //5

      int a = 2;
      int b = a + a;
      System.out.printf("%d + %d = %d", a, a, b); //
    }

解释的可以

标题打错了，应该是1000 == 1000返回为false，而100 == 100会返回true。

一脸懵逼啊

为IntegerCache.java之间的所有整数对象提供缓存。

似懂非懂

厉害了

厉害了。

厉害了哦

学习学习

很有意思，厉害啊

FAN8210 发表于 2016-11-28 06:47
为IntegerCache.java之间的所有整数对象提供缓存。

那些常用整数

。。。。。。。。。。