Comparing two Integer Wrapper classes

Question

why this program is printing false in first print statement and true in print statement.? i and i1 are two different objects so the first statement must print "true", which is as expected, but the second print statement prints "false" which creates a confusion.

public static void main(String[] args) {
        Integer i = new Integer(10);
        Integer i1 = new Integer(10);
        System.out.println(i == i1); //printing false
        i++;
        i1++;
        System.out.println(i == i1);//printing true
    }

Possible duplicate of [How to properly compare two Integers in Java?](http://stackoverflow.com/questions/1514910/how-to-properly-compare-two-integers-in-java) — ArcticLord, Aug 24 '16 at 07:22
@Ishan Can you check the wording of the question? You say "the first statement must print "true", which is as expected", but the listing shows the first statement printing false (similarly for the second print statement). — Andy Turner, Aug 24 '16 at 08:33

Andy Turner · Accepted Answer · 2016-08-24T07:22:55.477

5

Using the new keyword always creates two different instances. So the following is always true:

new Integer(10) != new Integer(10)

hence the first line printing "false".

Then:

i++;

hides the unboxing and boxing. It is equivalent to:

i = Integer.valueOf(i.intValue() + 1);

As described in the Javadoc of Integer.valueOf, values from -128 to 127 (at least) are cached: you are getting back the cached instance of Integer.valueOf(11) for both i++ and i1++, hence the second line printing "true".

edited Aug 24 '16 at 07:22

answered Aug 24 '16 at 07:20

Andy Turner

137,514
11
162
243

Interesting. When doing the same with +500, it actually really prints false the second time https://ideone.com/yvSSFS – baao Aug 24 '16 at 07:22
@baao it doesn't necessarily, it just happens to on ideone, currently. ["This method will always cache values in the range -128 to 127, inclusive, and may cache other values outside of this range."](https://docs.oracle.com/javase/7/docs/api/java/lang/Integer.html#valueOf(int)) Clearly 501 isn't cached by the JVM currently run by ideone. – Andy Turner Aug 24 '16 at 07:24
Ok, that makes sense. Thanks for the explanation! – baao Aug 24 '16 at 07:25

marcinj · Answer 2 · 2016-08-24T07:40:29.883

Here:

Integer i = new Integer(10);
Integer i1 = new Integer(10);

you ask for dynamically allocated two instances of Integer class type, this will give you two different references. If you change it to:

Integer i = 10;
Integer i1 = 10;

then reference of i and i1 will be equal because for small values wrapper classes use cached objects.

This:

    i++;
    i1++;

is explained in: 15.14.2. Postfix Increment Operator ++ in JLS (emphasis mine):

Before the addition, binary numeric promotion (§5.6.2) is performed on the value 1 and the value of the variable. If necessary, the sum is narrowed by a narrowing primitive conversion (§5.1.3) *and/or subjected to boxing conversion (§5.1.7) to the type of the variable before it is stored.

also a note below is important which says that before operator is applied an unboxing conversion may happen:

Note that the binary numeric promotion mentioned above may include unboxing conversion (§5.1.8) and value set conversion (§5.1.13). If necessary, value set conversion is applied to the sum prior to its being stored in the variable. so it means it is boxed back to the wrapper type

so in the end after applying an operator ++ to either reference type of allocated Integer instance or a boxed Integer class, you end with a boxed Integer if its value is in the correct range for boxed types.

score 0 · Answer 3 · answered Aug 24 '16 at 07:33

0

first is reference comparison, hence getting false and second is the value comparison (while incrementing, it is un-boxed to primitive int and hence incremented to 11 and auto-boxed again; same for i1) . second call is (11 == 11) hence true.

answered Aug 24 '16 at 07:33

GunjanK

1
1

score -1 · Answer 4 · answered Aug 24 '16 at 07:49

The Integer class has as many other classes implemented the equals method. You can easily compare two instances of Integer like this:

Integer int1 = new Integer(2);
Integer int2 = new Integer(2);
if(int2.equals(int1)) {
  // true
}

Consider implementing the equals method in all your own entity/dtos:

class Car {
  private String color;
  private Integer model;

  public Car(String color, Integer model) {
    this.color = color;
    this.model = model; 
  }

  public String getColor() { return color; }
  public Integer getModel() { return model; }

  @Override
  public boolean equals(final Object obj) {
    if(this == obj) {
      return true;  // You are actually comparing the same instances
    }
    if(obj instanceof Car) {  // Now you know both obj are instances of class Car
      final Car other = (Car) obj;  // Safe to cast
      return Objects.equal(color, other.getColor())
        && Objects.equal(model, other.getModel()
        ;
    }
    return false;
  }
}

Comparing two Integer Wrapper classes

4 Answers4