== operator does not compare references for String [duplicate]

This question already has answers here: Closed 11 years ago.

Possible Duplicate:

String comparison and String interning in Java

I understand how String equals() method works but was surprised by some results I had with the String == operator.

I would have expected == to compare references as it does for other objects.

However dis开发者_如何转开发tinct String objects (with the same content) == returns true and furthermore even for a Static String object (with the same content) which is obviously not the same memory address.

I guess == has been defined the same as equals to prevent its misuse

---

No, == does just compare references. However, I suspect you've been fooled by compile-time constants being interned - so two literals end up refererring to the same string object. For example:

String x = "xyz";
String y = "xyz";
System.out.println(x == y); // Guaranteed to print true

StringBuilder builder = new StringBuilder();
String z = builder.append("x").append("yz").toString();

System.out.printn(x == z); // Will print false

From section 3.10.5 of the Java language specification:

String literals-or, more generally, strings that are the values of constant expressions (§15.28)-are "interned" so as to share unique instances, using the method String.intern.

---

The reason it returns the same is because of memory optimizations (that aren't always guaranteed to occur) strings with the same content will point to the same memory area to save space. In the case of static objects they will always point to the same thing (as there is only one of it because of the static keyword). Again don't rely on the above and use Equals() instead.

One thing I should point out from Jon Skeet is that it is always guaranteed for compile time constants. But again just use equals() as it is clearer to read.

---

It is due to string intern pooling

See

• whats-the-difference-between-equals-and

---

The == operator does always compares references in Java and never contents. What can happen is that once you declare a string literal, this object is sent to the JVM's string pool and if you reuse the same literal the same object is going to be placed in there. A simple test for this behavior can be seen in the following code snippet:

String a = "a string";
String b = "a string";
System.out.println( a == b ); // will print true

String c = "other string";
String d = new String( "other string" );
System.out.println( c == d ); // will print false 

The second case prints false because the variable d was initialized with a directly created String object and not a literal, so it will not go to the String pool.

The string pool is not part of the java specification and trusting on it's behavior is not advised. You should always use equals to compare objects.

---

I guess == has been defined the same as equals to prevent its misuse

Wrong. What is happening here is that when the compiler sees that you are using the same string in two different places it only stores it in the program's data section once. Read in a string or create it from smaller strings and then compare them.

Edit: Note that when I say "same string" above, I'm referring only to string literals, which the compiler knows at runtime.