About String == String, please help.

[Guoqiao Sun]

Hi, all, please refer to the following code:

public class Test
{    
    public static void main(String args[])
    {
        Byte b1 = new Byte("127");
        
        if(b1.toString() == b1.toString())
            System.out.println("True");
        else
            System.out.println("False");        
    }    
}

The answer is <code>False</code>, why?
Thanks in advance.
Guoqiao
And the question comes from:
<code> http://www.geocities.com/skmajji/Main.html
</code>
Not bad questions there.
[This message has been edited by Guoqiao Sun (edited July 27, 2001).]

[Igor Gaschits]

I think, because each method toString() creates a new String in the String pool(because String(s) are not mutable as StringBuffer(s)).
== cheks if REFERENCES to objects are equal. Thus, the answer is False. However, if you use equals() instead of ==, you will get True.

[Ravindra Mohan]

Hi Guoqiao,
The reason is that the <code> toString() </code> method of <code>Object</code> class returns a new Object of the string representation of the object being passed as an argument.
Generally most classes overload this method as per their specific requirement. In the case of String class this is not
provided for, so the Object class's toString is called.
Further, the "==" operator checks the memory location of the
object and does a "shallow" comparison and returns true "if"
both the ojects have the same memory location else it returns
false. In the question you posted the toString() method returned
saperate string object which obviously have different memory locations and hence the result "false" is displayed at standard
console.
Hope this helps.
Ravindra Mohan.

[Guoqiao Sun]

Thank you, Ravindra for your detailed explanation.
Now i got it.
Guoqiao

[April.Johnson]

The reason is that the toString() method of Object class returns a new Object of the string representation of the object being passed as an argument.
Generally most classes overload this method as per their specific requirement. In the case of String class this is not
provided for, so the Object class's toString is called.

Actually, the String class does provide its own toString() method. But that really doesn't have any bearing on the code in the original question.
The original code is using a Byte object. The Byte class also provides its own toString() method. Byte's toString() method returns a new String object when it's called, so by calling byte.toString() (in the original code) twice, returns 2 different String objects. And given the nature of the == operator, the code will print False.
Also, calling toString() will not put a String object into the String pool. You have to call intern() on that object to do that. Interestingly enough (and logically), if you run the following code, you get a printout of True.

[CODE]public class TestByteString
{
public static void main(String args[])
{
Byte b1 = new Byte("127");
if(b1.toString().intern() == b1.toString().intern())
System.out.println("True");
else
System.out.println("False");
}
}[\code]
April
[This message has been edited by April.Johnson (edited July 27, 2001).]

[Desai Sandeep]

Yes, calling toString() twice on the Byre object creates two different String objects.Hence == gives false.
Using String.intern(), would not allow to create another instance of the String when byte.toString() is called the second time.Hence, it prints true in the output.
- Sandeep
SCJP2, OCSD(Oracle JDeveloper), OCED(Oracle Internet Platform)