How "==" works for objects?

public static void main(String [] a)
{
    String s = new String("Hai");
    String s1=s;
    String s2="Hai";
    String s3="Hai开发者_开发知识库";
    System.out.println(s.hashCode());
    System.out.println(s1.hashCode());
    System.out.println(s2.hashCode());
    System.out.println(s3.hashCode());
    System.out.println(s==s2);
    System.out.println(s2==s3);

}

From the above code can anyone explain what is going behind when JVM encounters this line (s==s2) ?

It compares references - i.e. are both variables referring to the exact same object (rather than just equal ones).

• s and s2 refer to different objects, so the expression evaluates to false.
• s and s1 refer to the same objects (as each other) because of the assignment.
• s2 and s3 refer to the same objects (as each other) because of string interning.

If that doesn't help much, please ask for more details on a particular bit. Objects and references can be confusing to start with.

Note that only string literals are interned by default... so even though s and s2 refer to equal strings, they're still two separate objects. Similarly if you write:

String x = new String("foo");
String y = new String("foo");

then x == y will evaluate to false. You can force interning, which in this case would actually return the interned literal:

String x = new String("foo");
String y = new String("foo");
String z = "foo";

// Expressions and their values:
x == y: false
x == z: false
x.intern() == y.intern(): true
x.intern() == z: true

EDIT: A comment suggested that new String(String) is basically pointless. This isn't the case, in fact.

A String refers to a char[], with an offset and a length. If you take a substring, it will create a new String referring to the same char[], just with a different offset and length. If you need to keep a small substring of a long string for a long time, but the long string itself isn't needed, then it's useful to use the new String(String) constructor to create a copy of just the piece you need, allowing the larger char[] to be garbage collected.

An example of this is reading a dictionary file - lots of short words, one per line. If you use BufferedReader.readLine(), the allocated char array will be at least 80 chars (in the standard JDK, anyway). That means that even a short word like "and" takes a char array of 160 bytes + overheads... you can run out of space pretty quickly that way. Using new String(reader.readLine()) can save the day.

== compars objects not the content of an object. s and s2 are different objects. If you want to compare the content use s.equals(s2).

Think of it like this.
  Identical twins look the same but they are made up differently.
If you want to know if they "look" the same use the compare.
If you want to know they are a clone of each other use the "=="

:)

== compares the memory (reference) location of the Objects. You should use .equals() to compare the contents of the object.

You can use == for ints and doubles because they are primitive data types

I suppose you know that when you test equality between variables using '==', you are in fact testing if the references in memory are the same. This is different from the equals() method that combines an algorithm and attributes to return a result stating that two Objects are considered as being the same. In this case, if the result is true, it normally means that both references are pointing to the same Object. This leaves me wondering why s2==s3 returns true and whether String instances (which are immutable) are pooled for reuse somewhere.

It should be an obvious false. JVM does a thing like using the strings that exist in the Memory . Hence s2,s3 point to the same String that has been instantiated once. If you do something like s5="Hai" even that will be equal to s3.

However new creates a new Object. Irrespective if the String is already exisitng or not. Hence s doesnot equal to s3,s4.

Now if you do s6= new String("Hai"), even that will not be equal to s2,s3 or s.

The literals s2 and s3 will point to the same string in memory as they are present at compile time. s is created at runtime and will point to a different instance of "Hai" in memory. If you want s to point to the same instance of "Hai" as s2 and s3 you can ask Java to do that for you by calling intern. So s.intern == s2 will be true.

Good article here.

You are using some '==' overload for String class...