Boxing confusion

[John McParland]

Hi all,

so in the two minute drill for Boxing (chapter 3, objective 3.1) says;

"Using == with wrappers created through boxing is tricky; those with the same small values (typically lower than 127), will be ==, larger values will not be ==."

So... what does this mean? Seemingly you simply cannot depend on == working with an Object created through boxing? I tried an experiment;

   
public class Boxing
{

   public static void main(String[] args)
   {
       // Try using == and != to compare wrappers to primitives

       // 127
       Integer j = new Integer(127);
       if (j == 127)
       {
          System.out.println("127 works with ==");
       }
       else
       {
          System.out.println("127 DOESN'T works with ==");
       }

       if (j != 129)
       {
          System.out.println("127 works with !=");
       }
       else
       {
          System.out.println("127 DOESN'T work with !=");
       }

       // Number bigger than 127
       Integer i = new Integer(500);
       if (i == 500)
       {
         System.out.println("500 works with ==");
       }
       else
       {
         System.out.println("500 DOESN'T work with ==");
       }

       if (i != 501)
       {
           System.out.println("500 works with !=");
       }
       else
       {
           System.out.println("500 DOESN'T work with !=");
       }

       // Really big number
       Integer k = new Integer(1000000);
       if (k == 1000000)
       {
          System.out.println("1000000 works with == in a method call");
       }
       else
       {
          System.out.println("1000000 DOESN'T work with == in a method call");
       }

       if (k != 1000001)
       {
           System.out.println("1000000 works with != in a method call");
       }
       else
       {
           System.out.println("1000000 DOESN'T work with != in a method call");
       }
       
       // Now use boxing to do the comparisson
       method127(127);
       method500(500);
       method1000000(1000000);
   }

   private static void method127(Integer val)
   {
       if (val == 127)
       {
          System.out.println("127 works with == in a method call");
       }
       else
       {
          System.out.println("127 DOESN'T work with == in a method call");
       }

       if (val != 129)
       {
          System.out.println("127 works with != in a method call");
       }
       else
       {
          System.out.println("127 DOESN'T work with != in a method call");
       }
   }

   private static void method500(Integer val)
   {
       if (val == 500)
       {
          System.out.println("500 works with == in a method call");
       }
       else
       {
          System.out.println("500 DOESN'T work with == in a method call");
       }

       if (val != 501)
       {
           System.out.println("500 works with != in a method call");
       }
       else
       {
           System.out.println("500 DOESN'T work with != in a method call");
       }
   }

   private static void method1000000(Integer val)
   {
       if (val == 1000000)
       {
          System.out.println("1000000 works with == in a method call");
       }
       else
       {
          System.out.println("1000000 DOESN'T work with == in a method call");
       }

       if (val != 1000001)
       {
           System.out.println("1000000 works with != in a method call");
       }
       else
       {
           System.out.println("1000000 DOESN'T work with != in a method call");
       }
   }

}

 

The output is;

   
127 works with ==
127 works with !=
500 works with ==
500 works with !=
1000000 works with == in a method call
1000000 works with != in a method call
127 works with == in a method call
127 works with != in a method call
500 works with == in a method call
500 works with != in a method call
1000000 works with == in a method call
1000000 works with != in a method call

which implies to me that comparing wrappers and primitives, regardless of whether boxing takes place, always works with == and !=.

Am I right or have I misunderstood the objective?

[Henry Wong]

which implies to me that comparing wrappers and primitives, regardless of whether boxing takes place, always works with == and !=.

Whenever you compare a wrapper with a primative, the wrapper object will always be unboxed for the comparison -- which is why all the conditionals worked in your example.

Am I right or have I misunderstood the objective?

I believe the quotes were referring to instance comparison of two wrappers that have been autoboxed -- and not a comparison between a wrapper and a primative. As there isn't much "tricky" about such a comparison.

Henry

[John McParland]

Thanks Henry. Yes it's when autoboxing has been used that == and != stop working;

    
public class Boxing2
{

    public static void main(String[] arg)
    {
        // Small numbers
        int x = 10;
        int y = 10;
        System.out.print("Comparing "+x+" and "+y+" using autoboxing: ");
        doIt(x,y);
        System.out.println();
        // Big numbers
        x = 128;
        y = 128;
        System.out.print("Comparing "+x+" and "+y+" using autoboxing: ");
        doIt(x,y);
        System.out.println();
    }
    
    private static void doIt(Integer i, Integer j)
    {
        if (i == j)
        {
            System.out.print("Equals (using ==): ");
        }
        else
        {
            System.out.print("Not equals (using ==): ");
        }
        
        if (i != j)
        {
            System.out.print("Not equals (using !=)");
        }
        else
        {
            System.out.print("Equals (using !=)");
        }
    }
}

[Krishna Srinivasan]

This article will be helpful:
http://today.java.net/pub/a/today/2005/03/24/autoboxing.html

[Jacob Sonia]

Hi, when i read this i understood this:

if we say
Integer i = 127;
Integer j = 127;
if(i == j) //returns true;
Integer i = 129;
Integer j = 129;
if(i == j) // returns false;
but it will not work here because using new always create a new object, so == starts comparing references now
Integer i = new Integer(127);
Integer j = new Integer(127);
if(i == j) //returns false

Correct me if i am wrong

[Bob Wheeler]

Jacob Sonia wrote:Hi, when i read this i understood this:

if we say
Integer i = 127;
Integer j = 127;
if(i == j) //returns true;
Integer i = 129;
Integer j = 129;
if(i == j) // returns false;
but it will not work here because using new always create a new object, so == starts comparing references now
Integer i = new Integer(127);
Integer j = new Integer(127);
if(i == j) //returns false

Correct me if i am wrong

"==" ALWAYS compares objects, NEVER references.
So, if you uses NEW, a new object is created, which results in "false" using "==".
But if you use autoboxing with a value between -128 and +127, the object is ALREADY
there (before autoboxing). So all references point to the same object resulting into a true output using "==".

cheers
Bob

[sandip sangale]

Comparison Value is Restricted To 127

[AmitKumar Jain]

Hi Bob,

I disagree slightly. Though you are correct, the statement requires correction.

== in case of references, checks whether the references point to the same object.
[ == in no way can compare objects , it just compares the references , which are
nothing but object handles ]

Amit

[Bob Wheeler]

AmitKumar Jain wrote:Hi Bob,

I disagree slightly. Though you are correct, the statement requires correction.

== in case of references, checks whether the references point to the same object.
[ == in no way can compare objects , it just compares the references , which are
nothing but object handles ]

Amit

Hi Amit,

actually I meant the same. If you compare references, you compare the objects where they point to (or the memory they point to).
For me two different references are different even if they point to the same object. So what is meant by different ? ...
I leave it here, as we are in the SCJP forum.

cheers
Bob

[AmitKumar Jain]

Hi Bob,

" For me two different references are different even if they point to the same object...."

Java always talks of references having a value which is a handle to an Object.
[ although the value is not known to us ]
Hence, when two references refer to the same Object, they are considered having the same value.

Even when we talk of Pass By Reference in method invocations, we say that copy(value) of
the reference is passed. Hence it is often said, "In Java, references are passed by value".

Amit.

[Bob Wheeler]

Hi Amit,

OK, now I get the difference between us. The JVM doesn't really compare the objects to which the references "point",
it compares what is stored in the references. So, if two references "point" to the same object they have the same value
stored. Then, there is no need to compare the object anymore.

Thanks for the insight.
cheers
Bob