Help please

[Jane Griscti]

Hi ...
I thought I understood the difference between using the == operator and the equals() method with String objects but the following code has me thoroughly confused

class TestComparison {
  public static void main(String[] args) {
  
    String s1 = "hello";
    String s2 = "hello";
    String s3 = s1;
    String s4 = new String("hello");
    System.out.println("\t     Equals: s1 == s2 \t\t " +
        (s1 == s2));
    System.out.println("\t     Equals: s1 == s3 \t\t " +
        (s1 == s3));
    System.out.println("\t     Equals: s1 == s4 \t\t " +
        (s1 != s4));
  }
}
Output:
 Equals: s1 == s2            true
 Equals: s1 == s3            true
 Equals: s1 == s4            true

I thought I would see:

Output:
 Equals: s1 == s2            false
 Equals: s1 == s3            true
 Equals: s1 == s4            false

Would someone please explain why they all came up true?
Thanks

[Paul A]

Pls see my post here... http://www.javaranch.com/ubb/Forum24/HTML/004044.html
------------------
http://pages.about.com/jqplus
Get Certified, Guaranteed!

[Jane Griscti]

Thanks Paul. Think I've finally got it but just in case, does the following sound right:

• if String objects having the same data are created using a constant expression, a string literal, a reference to an existing string, or by explicitly using the intern() method, their references will be the same
  
• if String objects having the same data are created explicitly with the new operator or their values are computed at runtime, their references will be different
  



 String str1 = "Lions and Tigers and Bears!";
 String str2 = "Lions and Tigers and Bears!";
 String str3 = str2;
 String str4 = new String("Lions and Tigers and Bears!");
 String str5 = " Oh my!";
 String str6 = "Lions and Tigers and Bears! Oh my!";
 String str7 = str1 + str5;
 String str8 = (str1 +" Oh my!").intern();
Comparison output:
    str1 == str2    -> true     // the str2 literal existed ("interned")
    str1 == str3    -> true     // hold the same reference
    str1 == str4    -> false    // str4 explicitly created
    str2 == str3    -> true     // hold the same reference
    str2 == str4    -> false    // str4 explicitly created
    str3 == str4    -> false    // str4 explicitly created
    str6 == str7    -> false    // str7 computed at runtime
    str6 == str8    -> true     // explicit use of intern() at runtime


Thanks

[This message has been edited by Jane Griscti (edited September 14, 2000).]

[Barbara Dyer-Bennet]

The way I read the line:
System.out.println("\t Equals: s1 == s4 \t\t " + (s1 != s4));
the expression (s1 != s4) comes up as true because you have a trick in there... s1 is NOT equal to s4, so the print statement displays the word true. I hope this helps.

[Anonymous]

By the way, let me just add another excellent example which will clear everybody's concept about String literals:
Here it goes:

package testPackage;
     class Test {
             public static void main(String[] args) {
                     String hello = "Hello", lo = "lo";
                     System.out.print((hello == "Hello") + " ");
                     System.out.print((Other.hello == hello) + " ");
                     System.out.print((other.Other.hello == hello) + " ");
                     System.out.print((hello == ("Hel"+"lo")) + " ");
                     System.out.print((hello == ("Hel"+lo)) + " ");
                     System.out.println(hello == ("Hel"+lo).intern());
             }
     }
     class Other { static String hello = "Hello"; }
and the compilation unit:
     package other;
     public class Other { static String hello = "Hello"; }

produces the output:
true true true true false true
This example illustrates six points:
Literal strings within the same class (�8) in the same package (�7) represent references to the same String object (�4.3.1).
Literal strings within different classes in the same package represent references to the same String object.
Literal strings within different classes in different packages likewise represent references to the same String object.
Strings computed by constant expressions (�15.28) are computed at compile time and then treated as if they were literals.
Strings computed at run time are newly created and therefore distinct.
The result of explicitly interning a computed string is the same string as any pre-existing literal string with the same contents.
Hope this helps all of us for the exam
-sampaths77
[I added UBB CODE tags to your source code to make it more readable. Please try to use them in the future. Learn more about UBB codes - Ajith]
[This message has been edited by Ajith Kallambella (edited September 15, 2000).]

[Jane Griscti]

Thanks Barbara, Sampaths77 ... I noticed the "!=" after banging my head against the code for an hour or so Oh well, it forced me to go through the JLS on String literals so in the end I learned from it.
Jane