== with Strings is giving a different result

[Mo Bustany]

Given the following

 
public class EqualTest {
    public static void main(String[] args) {
        EqualTest equalTest1 = new EqualTest();
        String s1 = "abc";
        String s2 = "ab" + "c";
        String s3 = "ab";
        String s4 = s3 + "c";
        if (s1 == s2)
            System.out.println("s1==s2");        // prints s1==s2
        if (s1 == s4)
            System.out.println("s1==s4");        // no output!!!!
        if (s2.equals(s1))
            System.out.println("s2 equals s1");  // prints s2 eqs s1
    }
}

Why isn't s1 identical to s4 but s2 is identical to s1!!!

[Veena Pointi]

Coz == operator compares object references(memory addresses which is bit representaion),but equlas() method compares objects .Coz equals() method is overriden in String class.
s1,s2,s3,s4 all are different objects reffering to different memory locations on the heap .So if you compare any of the above 2 objects using == ,it returns false.
Veena

[Varun Khanna]

The behaviour of equals() function is fine.
Regarding == comparison, the string s1 and s2 are pointing to same object in the compiler's pool whereas s4(=s3 + "c")is an object on heap and hence is not pointing to the "abc" object present in the pool.Hence, s1 and s2 are same whereas s4 is pointing to different location.
You can also try to add a String s5 = s1; and comparing s1 == s5 is returning true.As both are pointing to object in compiler's pool.
Further, to verify this try to add this line of code ---->
if (s1 == s4.intern())
System.out.println("s1==s4");
<----
This returns true, as calling intern method, returns the string form of s4 object from the pool.
Hope this helps.
Varun
[ June 25, 2003: Message edited by: varun Khanna ]

[Anupam Sinha]

Hi Mo
It's so because s1 and s2 refer to the same thing because "abc" and "ab" + "c" are both compile time constants. So the value is calculated at compile time. But the value of s3 + "c" is calculated at runtime and hence s3 + "c" is not in the pool. That is s3 + "c" is a freshly made string and hasn't been interned so a new memory location is assigned to it. Though both the Strings are identical except the fact that their memory locations are different.
[ June 25, 2003: Message edited by: Anupam Sinha ]

[Marlene Miller]

Here is what the compiler does for �ab� + �c�;
s2 = �abc�; //store a reference to String object in this variable.
The concatenation of two compile-time String constants is a compile-time String constant.
Here is what the compiler does for s3 + �c�:
StringBuffer sb = new StringBuffer();
sb.append(s3);
sb.append(�c�);
s4 = sb.toString(); //create a new String object
The concatenation of a String variable and a compile-time String constant is a run-time computation to create a new String object.

[Marlene Miller]

Even if you are not familiar with byte-codes, it can be somewhat convincing to see what the compiler is doing.

class Test {
   public static void main(String[] args) {
      String s1 = "abc";
      String s2 = "ab" + "c";
      String s3 = "ab";
      String s4 = s3 + "c";
   }
}
//
Method void main(java.lang.String[])
   0 ldc #2 <String "abc">
   2 astore_1              //s1
   3 ldc #2 <String "abc">
   5 astore_2              //s2
   6 ldc #3 <String "ab">
   8 astore_3              //s3
   9 [B]new[/B] #4 <Class java.lang.StringBuffer>
  12 dup
  13 invokespecial #5 <Method java.lang.StringBuffer()>
  16 aload_3  //s3
  17 invokevirtual #6 <Method java.lang.StringBuffer [B]append(java.lang.String)[/B]>
  20 ldc #7 <String "c">
  22 invokevirtual #6 <Method java.lang.StringBuffer [B]append[/B](java.lang.String)>
  25 invokevirtual #8 <Method java.lang.String [B]toString()[/B]>
  28 astore 4  //s4
  30 return