Why are equal java strings taking the same address?

Question

Possible Duplicate:
String object creation using new and its comparison with intern method

I was playing around with Strings to understand them more and I noticed something that I can't explain :

String str1 = "whatever";
String str2 = str1;
String str3 = "whatever";
System.out.println(str1==str2); //prints true...that's normal, they point to the same object
System.out.println(str1==str3); //gives true..how's that possible ?

How is the last line giving true ? this means that both str1 and str3 have the same address in memory.

Is this a compiler optimization that was smart enough to detect that both string literals are the same ("whatever") and thus assigned str1 and str3 to the same object ? Or am I missing something in the underlying mechanics of strings ?

The javac compiler can detect such simple case and only allocate the space for the String once and reuse it. During run time, it is another story. — nhahtdh, Nov 19 '12 at 08:58
http://stackoverflow.com/a/513839/1273830 > "Because these literals are interned by the compiler and thus refer to the same object!" — Prasanth, Nov 19 '12 at 09:08

Parth Soni · Answer 1 · 2012-11-19T09:07:04.800

Because Java has a pool of unique interned instances, and that String literals are stored in this pool. This means that the first "whatever" string literal is exactly the same String object as the third "whatever" literal.

As the Document Says:

public String intern()

Returns a canonical representation for the string object. A pool of strings, initially empty, is maintained privately by the class String.

When the intern method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

All literal strings and string-valued constant expressions are interned. String literals are defined in §3.10.5 of the Java Language Specification

Returns: a string that has the same contents as this string, but is guaranteed to be from a pool of unique strings.

To add a note about that you shouldn't do string1==string2, anyway as it's not guaranteed that there will never two instances of a given "text". Always use string1.equals(string2) or whatever is appropriate for comparision in your context. — philnate, Nov 19 '12 at 09:01

score 6 · Accepted Answer · answered Nov 19 '12 at 09:00

http://www.xyzws.com/Javafaq/what-is-string-literal-pool/3

As the post says:

String allocation, like all object allocation, proves costly in both time and memory. The JVM performs some trickery while instantiating string literals to increase performance and decrease memory overhead. To cut down the number of String objects created in the JVM, the String class keeps a pool of strings. Each time your code create a string literal, the JVM checks the string literal pool first. If the string already exists in the pool, a reference to the pooled instance returns. If the string does not exist in the pool, a new String object instantiates, then is placed in the pool.

Maroun · Answer 3 · 2012-11-19T09:09:09.820

If you do:

String str1 = new String("BlaBla");  //In the heap!
String str2 = new String("BlaBla");  //In the heap!

then you're explicitly creating a String object through new operator (and constructor). In this case you'll have each object pointing to a different storage location.

But if you do:

String str1 = "BlaBla";        
String str2 = "BlaBla";

then you've implicit construction. Two strings literals share the same storage if they have the same values, this is because Java conserves the storage of the same strings! (Strings that have the same value)

score 1 · Answer 4 · answered Nov 19 '12 at 09:03

The javac compiler combines String literals which are the same in a given class file.

However at runtime, String literals are combined using the same approach as String.intern() This means even Strings in different class in different applications (in the same JVM which use the same object.

Why are equal java strings taking the same address?

4 Answers4

Linked