Strings in Java : equals vs == [duplicate]

Answer 1

When you use == on strings, only the references are compared. Thus, == is only guaranteed to return true in situations like:

String s1 = "...";
String s2 = s1;    // reference assignment!

Here, s1 == s2. In all other situations, == may or may not return true even if the two strings contain the same character sequence.

To compare the contents of the two strings, use equals():

if (s1.equals(s2)) {
   ...
}

Answer 2

Only interned (String.intern()) strings are safe to compare with == for all other cases you should use equals.

In your case you define your own type MyString which has small in common with java String so comparing s and s1 you compare references to two distinct objects that is why you got false.

Answer 3

From the java virtual machine spec:

String literals and, more generally, strings that are the values of constant expressions are "interned" so as to share unique instances, using the method String.intern.

"andrei" is a String literal and therefore "interned". Therefore both String s1and s2 refer to the same String object, an interned String with the content "andrei".

Therefore (s1 == s2) && (s1.equals(s2)) is true. String#toString() doesn't create a new String (like many other methods from String) but simple returns this. Therfore s2 == s3 is true.

Answer 4

When comparing s == s1 you are comparing two different MyString objects. Think of your situation like this

s and s1 are different objects, but their attribute point to the same instance of toto.

They are different objects because of the way you create them:

MyString s = new MyString("toto");
MyString s1 = new MyString("toto");

So s == s1 will return false. For it to return true, they had to be the same object. You could achieve it like this:

MyString s = new MyString("toto");
MyString s1 = s;

That would be the result

Answer 5

"==" is compare reference. But Equals() method in Object class is compare reference only. And the behavior of method equals() in the subclass is based on the implement of overriding this method.

Answer 6

Since String are immutables, a useful implementation of the toString method is - in the String class - to return this.

As an example, my rt.jar contains the following implementation :

public String toString() {
return this;
}

As a consequence, the reference associated to s3 is the same than the one associated to s2.

Considering the s1==s2 statement, it is due to the automatic call to intern() for all constant Strings. That means that at compile time, s2 initialization code will be replaced by s2=s1, which makes the assertion quite obvious, no ?