java - String Constant Pool

itemprop="text">

As explained in these Stackoverflow
questions: href="https://stackoverflow.com/questions/2009228/strings-are-objects-in-java-so-why-dont-we-use-new-to-create-them">question
1 & href="https://stackoverflow.com/questions/1881922/questions-about-javas-string-pool">question
2 I understand that "String literals" are href="http://en.wikipedia.org/wiki/String_interning"
rel="noreferrer">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.

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.

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

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.