Strings in Java : equals vs == [duplicate]

Answer 1

s2.toString () is returning a String representation. Since it's already a String it returns itself (thats why the comparison is true).

All Strings are allocated on the Heap, the coparison operator just compares whether they are the same object (thats why s1 != s2).

Answer 2

The reason for the first comparison to fail is, that you do create two Objects by calling new. Now, the == operator does compare two memory addresses, which yields the return you got because the two objects are not at the same memory cell.

The reason why it works with constant Strings is, that the java compiler, javac, does optimize the code. By that optimisation similar string constants are being placed in one and the same memory cell. If you would have done the following, then the result would have been the same for your String objects.

String s2 = new String("toto");
String s3 = new String("toto");
System.out.println(s2==s3); //yields false!!

Your way to go is .equals(other). For that you'll have to implement the method equals in the class Mystring:

class MyString{

    private String s;

    public MyString (String s){
        this.s = s;
    }

    public String getContent(){
        return s;
    }

    @Override
    public boolean equals(Object other){
        if(other instanceof MyString){
            MyString compareTo = (MyString) other;
            return this.s.equals(compareTo.getContent());
        }
        return false;
    }
}

Answer 3

Why the first result is false ?

== compares references and you create two different objects.

I understood that for none primitive types, when we do '==',

A String is not a primitive. References will be == when they refer to the same object.

Answer 4

Every instance of MyString sits in a different memory location, so, forgetting about the contents of the instances, for every two different instances the == test is going to result in false.

In case of the String class, there's a small, but important difference, when you do assignment of a String variable and the right hand side operator is a literal (i.e. String s = "foo";), a new memory location is going to be occupied by "foo" only if "foo" was not encountered before as a literal. If this is the case (i.e. String s = "foo"; String otherS = "foo";), otherS is just going to reference the already present "foo".

This behaviour is called String pooling.

Answer 5

First of all String.toString is a no-op:

/**
 * This object (which is already a string!) is itself returned.
 *
 * @return  the string itself.
 */
public String toString() {
    return this;
}

Second of all, String constants are interned so s1 and s2 are behind the scenes changed to be the same String instance.

Answer 6

Basically when you use new String("something") you're forcing Java to create a brand new object.

When you assign to a String literal ="something", that string is stored in the constant pool, an optimization done by the JVM. So when you assign another reference to the same constant, the Object stored in the constant pool gets reused, basically, it's the same object.