字符串intern（）方法使用混乱

Question

We use intern() method for the Strings which are created through new String() so that they will create an entry in String Pool and return the newly created String from the String Pool so that this created string is eligible for use with == operator (as per my understanding).

Then what is the use of creating a new String through constructor?

When should we use constructor for creating new String?

Answer 1

new String() can create at-most two Objects of String and at-least one. one in constant pool (if same is not present in constant pool) and another in heap memory. constant pool entry is created by interning String object.

intern will create String Literal in Constant pool so that whenever you create String without new keyword it will not create string object.

suppose you have created as

String str= new String("abc");

two object will be created one in constant pool (if "abc" is not present in constant pool). jvm wil internally call intern for that object. so next time if you are doing

String str1= "abc";

no entry will be added to constant pool because only entry can be possible in constant pool for same literal.

Answer 2

public native String intern(); java doc says, 

A pool of strings, initially empty, is maintained privately by the class >{@code String}. When the intern method is invoked, if the pool already >contains a string equal to this {@code String} object as determined by >the {@link #equals(Object)} method, then the string from the pool is >returned. Otherwise, this {@code String} object is added to the pool and >a reference to this {@code String} object is returned. It follows that >for any two strings {@code s} and {@code t}, {@code s.intern() == >t.intern()} is {@code true} if and only if {@code s.equals(t)} is {@code >true}.

Let's consider an example:

String temp1 = new String("abcd"); this means, a new object "abcd" will be created in the heap memory and its reference will be linked to temp1 .

String temp2 = new String("abcd").intern(); this means "abcd" literal will be checked in the String Pool . If already present, its reference will be linked to newly created temp2 . Else a new entry will be created in String Pool and its reference will be linked to newly created temp2 .

String temp3 = "abcd"; this means "abcd" literal will be checked in the String Pool . If already present, its reference will be linked to newly created temp2 . Else a new entry will be created in String Pool and its reference will be linked to newly created temp3 . This conclude that, Java automatically interns String literals .

Let's consider another example:

String s1 = "string-test";

String s2 = new String("string-test");

String s3 = new String("string-test").intern();

if ( s1 == s2 ){
    System.out.println("s1 and s2 are same");
}

if ( s2 == s3 ){
    System.out.println("s2 and s3 are same" );
}

if ( s1 == s3 ){
    System.out.println("s1 and s3 are same" );
}

Output: s1 and s3 are same

Now when to create a String object using = " " or using new String(" ") ?

One use case which I came across,

// imagine a multi-megabyte string here String s = "0123456789012345678901234567890123456789"; String s2 = s.substring(0, 1); s = null;

You'll now have a String s2 which, although it seems to be a one-character string, holds a reference to the gigantic char array created in the String s. This means the array won't be garbage collected, even though we've explicitly nulled out the String s!

The fix for this is to use String constructor like this:

String s2 = new String(s.substring(0, 1));