primitive == Wrapper converts to primitive == primitive or Wrapper == Wrapper?

Question

I suppose that conversions described in jls are sorted according the priority. first has greate priority.

Thus I solved that Boxing has greater priority than Unboxing. I decided to check this assumption.

research following code:

public class BoxingUnboxingPriority {
    public static void main(String [] args){
        int sn = 1000;
        Integer isn1= new Integer(sn);
        System.out.println(sn == isn1 );

    }
}

out:

true

What is boxing? is just new Integer(primitiveInt)

I changed the code a bit

int sn = 1000;
Integer isn1= new Integer(sn);
Integer isn2= new Integer(sn);
System.out.println(isn1 == isn2 );

out:

false

Thus I made mistake.

Please clarify me this issue.

Use `.equals` instead of `==` to compare the objects. `==` checks to see if they are the **same object**, which they aren't as you used `new` to create them both. `.equals` would return `true` because they represent the same number. — JonK, Apr 08 '14 at 11:45
@Andremoniy там вообще не про джаву даже! — gstackoverflow, Apr 08 '14 at 11:45

score 2 · Answer 1 · edited Jun 20 '20 at 09:12

2

The relevant section:

15.21.1. Numerical Equality Operators == and !=

If the operands of an equality operator are both of numeric type, or one is of numeric type and the other is convertible (§5.1.8) to numeric type, binary numeric promotion is performed on the operands (§5.6.2).

So:

Integer o = 1;
int i = 1;
boolean b = o == i;

...is equivalent to:

boolean b = o.intValue() == i;

Where both are of type Integer neither is a primitive numeric type - they are both object references.

edited Jun 20 '20 at 09:12

Community

1
1

answered Apr 08 '14 at 11:49

McDowell

107,573
31
204
267

What is numeric type? – gstackoverflow Apr 08 '14 at 11:51
[The numeric types are the integral types and the floating-point types.](http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.2) – McDowell Apr 08 '14 at 11:52

score 1 · Answer 2 · answered Apr 08 '14 at 11:43

1

When you use primitive with a Wrapper object, that wrapper object will be unboxed and then the operation will be applied.

In your first case, when you comparing sn with isn1, isn1 will be unboxed and the value will be compared. So you got true.

In second case, isn1, isn2 are two different object, so == operator will give false

answered Apr 08 '14 at 11:43

Abimaran Kugathasan

31,165
11
75
105

thus **conversions described in jls are sorted according the priority** this clause is wrong ? – gstackoverflow Apr 08 '14 at 11:48
no, the second case simply has nothing to do with boxing/unboxing, it is just a reference equality for two objects – Oleg Estekhin Apr 08 '14 at 12:03
@OlegEstekhin : I never say, it has something with boxing/unboxing. – Abimaran Kugathasan Apr 08 '14 at 12:06

Stephen C · Answer 3 · 2014-04-08T12:23:39.283

I suppose that conversions described in jls are sorted according the priority.

That is incorrect. The JLS does not talk about "priorities" for conversions. It is not a recognized concept.

In fact, the conversions that can be applied are documented on a case by case basis for each operator, and so on. Thus JLS 15.21.1 says that == or != for numeric types results in "binary numeric promotion" of both operands. And JLS 5.6.2 says that binary numeric promotion consists of "unboxing conversion" (5.1.8) followed by "widening primitive conversion" (5.1.2) and finally "value set conversion" (5.1.3).

By contrast, JLS 15.21.3 says that when two references are compared using == or !=, no promotions or conversions take place.

(In fact, a common Java beginners mistake is to use == to compare two Integer objects rather than the equals(Object) method. And probably that is what "the question" you are looking at is trying to test your understanding of ...)

score 0 · Answer 4 · answered Jun 04 '15 at 13:01

int sn=1000; Integer isn1=new Integer(sn); System.out.println(sn == isn1 );

will be converted to

System.out.println(sn == isn1.intValue());

while comparing primitive with wrapper the wrapper object first will be unboxed and then comparison. wrapper object intValue() returns int so due to primitive comparison result true.

Integer isn1= new Integer(sn);

Integer isn2= new Integer(sn); System.out.println(isn1 == isn2 );

// comparing two different object so false.

primitive == Wrapper converts to primitive == primitive or Wrapper == Wrapper?

4 Answers4