String Constant Pool

Solution 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.

Solution 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 !!!

Solution 3:

Your question :

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?:

Ans : When you create a new string object by using new keyword, the address generated will be a heap address, not a string constant pooled address. And both the addresses are different.

Questions :

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

System.out.println(one.equals(two)); // true
System.out.println(one == two);      // false

do the previous statements mean that they will be put in pool memory but simply skipped when the new operator is used?

Answer : Yes, your assumption is correct. When programmer uses new keyword, JVM will simply ignore about string constant pool, and creates a new copy in the Heap. Hence both the addresses are not same.

Solution 4:

"abc" puts an object into the constant pool, at compile/class-load time, and new String() creates a new object, at execution time. So new String("abc") does both, but at different phases.