Over a million developers have joined DZone.

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

DZone's Guide to

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

Here's a little code puzzler to help you be a little better at Java.

· Java Zone
Free Resource

Build vs Buy a Data Quality Solution: Which is Best for You? Gain insights on a hybrid approach. Download white paper now!

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


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.


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

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

Build vs Buy a Data Quality Solution: Which is Best for You? Maintaining high quality data is essential for operational efficiency, meaningful analytics and good long-term customer relationships. But, when dealing with multiple sources of data, data quality becomes complex, so you need to know when you should build a custom data quality tools effort over canned solutions. Download our whitepaper for more insights into a hybrid approach.

java ,cache

Published at DZone with permission of A. N. M. Bazlur Rahman, DZone MVB. See the original article here.

Opinions expressed by DZone contributors are their own.

{{ parent.title || parent.header.title}}

{{ parent.tldr }}

{{ parent.urlSource.name }}