积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

目录

今天看到一篇有意思的文章，如果条件可以，可以自行动手试试。讲的是：
为什么 Java 中”1000==1000”为false，而”100==100”为true？

代码：

Integer a = 1000, b = 1000;  
System.out.println(a == b);
Integer c = 100, d = 100;  
System.out.println(c == d);

得到的结果：

false
true

我们都知道（假装都知道）。如果两个引用指向同一个对象，用 == 表示它们是相等的。如果两个引用指向不同的对象，用 == 表示它们是不相等的，即使它们的内容相同。

所以，上面的输出结果，应该都是false才对。但，为什么不是呢？这就是它有趣的地方了。

1.正文

这里是100。
如果你看去看 Integer.java 类，你会发现有一个内部私有类，IntegerCache.java，它缓存了从 - 127 到 128 之间的所有的整数对象。所以，所有的小整数在内存缓存。
当我们类似这样声明：

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);
    }

可以看见，默认IntegerCache.low 是-127，Integer.high是128，如果在这个区间内，他就会把变量i当做一个变量，放到内存中；但如果不在这个范围内，就会去new一个Integer对象。如果值的范围在-127 到 128 之间，它就从高速缓存返回实例。
所以，

Integer c = 100, d = 100;

他们是指向了同一个对象。所以为什么后一句是true了。所以，大于128的用equals比较。

2.疑问

可能有人会问，为什么这里需要缓存？

合乎逻辑的理由是，在此范围内的 “小” 整数使用率比大整数要高，因此，使用相同的底层对象是有价值的，可以减少潜在的内存占用。

然而，通过反射 API 你会误用此功能。
可以自行体验：

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
  
  	//System.out.printf("2 + 2 = %d",2 + 2); 等同下面
  
        int a = 2;
        int b = a + a;
        System.out.printf("%d + %d = %d", a, a, b); //
    }

这里把输出结果给出来，让你们惊讶惊讶（我编译器没问题啊）。

2 + 2 = 5

具体情况，下一篇解释。今天收获满满。