String Constant Pool

Question

As explained in these Stackoverflow questions: question 1 & question 2 I understand that "String literals" are interned when:

String s = "abc";  

And that the JVM will create a new String object instead of using an existing one from the String Pool when:

String s = new String("abc"); 

However, I have a doubt after reading the following two similar statements.

• From SCJP preparation book:

When the compiler encounters a String literal, it checks the pool to see if an identical String already exists. If a match is found, the reference to the new literal is directed to the existing String, and no new String literal object is created.

• From JavaRanch:

In this case, we actually end up with a slightly different behavior because of the keyword "new." In such a case, references to String literals are still put into the constant table (the String Literal Pool), but, when you come to the keyword "new," the JVM is obliged to create a new String object at run-time, rather than using the one from the constant table.

So if we also put a reference in nonpool memory AND in pool memory when we create an object using "new" and based on the definitions above. Shouldn't the JVM also return the same reference when we do this?:

String one = new String("test"); String two = "test";  System.out.println(one.equals(two)); // true System.out.println(one == two);      // false 

Because when declaring the String literal String three = "test"; it will already exist in the pool? and therefore should return the same reference and print true? or do the previous statements mean that they will be put in pool memory but simply skipped when the new operator is used?

Answer 1

Maybe this will aid your understanding:

String literal = "test"; String one = new String(literal); String two = "test";  System.out.println(literal == two); //true System.out.println(one == two); //false 

In the example you posted:

String one = new String("test"); String two = "test"; 

the reference passed to the constructor String(String) has the same value as the reference two due to interning. However, the string itself (referenced by these two references) is used to construct a new object which is assigned to reference one.

In this example, there are exactly two Strings created with the value "test": the one maintained in the constant pool and referenced whenever you use the literal "test" in an expression, and the second one created by the "new" operator and assigned to the reference one.

Edit

Perhaps you're confused about this statement:

When the compiler encounters a String literal, it checks the pool to see if an identical String already exists.

Note that this might be more clearly stated as:

When the compiler encounters a String literal, it checks to see if an identical String already exists in the pool.

Strings are only put in the pool when they are interned explicitly or by the class's use of a literal. So if you have, for example, this scenario:

String te = "te"; String st = "st";  String test = new String(te) + new String(st); 

then while a String will exist with the value test, said String will not exist in the pool as the literal "test" has never occurred.

Answer 2

    //Creates a new object even if one exists in the pool     String s1 = new String("Tendulkar");      // makes a new object string and then the reference is available to the pool     String s2 = s1.intern();      //this object is not created but references the address present in the pool     String s3 = "Tendulkar";      System.out.print(s1==s2); // results in false     System.out.print(s2==s3); //very very true !!!