Over a million developers have joined DZone.
{{announcement.body}}
{{announcement.title}}

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

Learn how to troubleshoot and diagnose some of the most common performance issues in Java today. Brought to you in partnership with AppDynamics.

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


Understand the needs and benefits around implementing the right monitoring solution for a growing containerized market. Brought to you in partnership with AppDynamics.

Topics:
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.

THE DZONE NEWSLETTER

Dev Resources & Solutions Straight to Your Inbox

Thanks for subscribing!

Awesome! Check your inbox to verify your email so you can start receiving the latest in tech news and resources.

X

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

{{ parent.tldr }}

{{ parent.urlSource.name }}