Why 1000 == 1000 Returns False, but 100 == 100 Returns True in Java?

This is probably one of the well discussed topic, but I found it interesting.

if you run the following code

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

You will get

false
true

Here are the basics: we know that , if two references point to the same object, they are equal in terms of ==. If two references point to different objects, they are not equal in terms of == even though they have the same contents.

So here the last statement should be false as well.

This is actually where it gets interesting. If you look into the Integer.java class , you will find that there is an inner private class, IntegerCache.java that caches all Integer objects between -128 and 127.

So the thing is, all small integers are cached internally and when we declare something like –

Integer c = 100;

What it does internally is

Integer i = Integer.valueOf(100);

Now if we look into the valueOf() method , we will see-

public static Integer valueOf(int i) {

  if (i >= IntegerCache.low && i
      return IntegerCache.cache[i + (-IntegerCache.low)];

  return new Integer(i);
}

If the value is in the range -128 to 127, it returns the instance from the cache.

So…

Integer c = 100, d = 100;

basically points to the same object.

Thats why when we write

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

We get true.

Now you might ask, why does this require caching?

Well, the logical rationale is that “smaller” integers in this range are used much more often than larger ones, so using the same underlying objects is worth it to reduce the potential memory footprint.

However, you can abuse this feature using the reflection API.

Run the following code, and enjoy the magic

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

转载自Java Zone
这就涉及到 Integer 神奇的缓存机制，后续会继续更新