What is the purpose of Java's String.intern()?

Question

I know there are two ways of creating String in Java:

String a = "aaa";
String b = new String("bbb");

With the first way Java will definitely create a String object in the string pool and make a refer to it. (Assume "aaa" wan't in the pool before.)

With the second method, an object will be created in the heap, but will jvm also create an object in the string pool?

In this post Questions about Java's String pool, @Jesper said:

If you do this:

String s = new String("abc");

then there will be one String object in the pool, the one that represents the literal "abc", > and there will be a separate String object, not in the pool, that contains a copy of the > content of the pooled object.

If that's true, then every time with the new String("bbb");, a object "bbb" is created in the pool, which means by either way above, java will always create a string object in the pool. Then what is intern() used for ? In the docs http://docs.oracle.com/javase/7/docs/api/java/lang/String.html#intern(), it says:

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.

That means there are cases that a string is not in the pool, is that possible ? Which one is true ?

Answer 1

As you know that String is an immutable object in Java programming language, which means once constructed can not be altered. Due to this, JVM has the ability to maintain a literal pool which is helpful to reduce the memory usage and to increase the performance. Each time when a String literal is used JVM checks the literal pool. If the literal is already available, the same reference would be returned. If the literal is not available, a new String object will be created and added in the literal pool.

This theory is applied when you try to create a String like a primitive or a literal/constant.

String str = "bbb";

But when you create a new String object

String str = new String("bbb");

the above mentioned rules are overridden and a new instance is created always.

But the intern API in the String class can be used to pick the String reference from the literal pool even though you create a String using new operator. Please check the below given example. Although the str3 is created using new operator since we used the intern method JVM picked up the reference from the literal pool.

public class StringInternExample {

    public static void main(final String args[]) {

        final String str = "bbb";
        final String str1 = "bbb";
        final String str2 = new String("bbb");
        final String str3 = new String("bbb").intern();

        System.out.println("str == str1 : "+(str == str1));
        System.out.println("str == str2 : "+(str == str2));
        System.out.println("str == str3 : "+(str == str3));
    }
}

Output of above code:

str == str1 : true
str == str2 : false
str == str3 : true

You can have a look: Confusion on string immutability

Source of answer: http://ourownjava.com/java/java-string-immutability-and-intern-method/

Shishir

Answer 2

There are essentially two ways that our String objects can enter in to the pool:

• Using a literal in source code like "bbb".
• Using intern.

intern is for when you have a String that's not otherwise from the pool. For example:

String bb = "bbb".substring(1); // substring creates a new object

System.out.println(bb == "bb");          // false
System.out.println(bb.intern() == "bb"); // true

Or slightly different:

System.out.println(new String("bbb").intern() == "bbb"); // true

new String("bbb") does create two objects...

String fromLiteral = "bbb";                     // in pool
String fromNewString = new String(fromLiteral); // not in pool

...but it's more like a special case. It creates two objects because "bbb" refers to an object:

A string literal is a reference to an instance of class String [...].

Moreover, a string literal always refers to the same instance of class String.

And new String(...) creates a copy of it.

However, there are many ways String objects are created without using a literal, such as:

• All the String methods that perform some kind of mutation. (substring, split, replace, etc.)
• Reading a String from some kind of input such as a Scanner or Reader.
• Concatenation when at least one operand is not a compile-time constant.

intern lets you add them to the pool or retrieve an existing object if there was one. Under most circumstances interning Strings is unnecessary but it can be used as an optimization because:

• It lets you compare with ==.
• It can save memory because duplicates can be garbage collected.

Answer 3

Yes, new String("abc") will create a new object in memory, and thus it is advised to avoid it. Please have a look at item 5 of Josh Bloch's Effective Java, "Avoid creating unnecessary objects" where it is better explained:

As an extreme example of what not to do, consider this statement:

String s = new String("stringette"); // DON'T DO THIS!

The statement creates a new String instance each time it is executed, and none of those object creations is necessary. The argument to the String constructor ("stringette") is itself a String instance, functionally identical to all of the objects created by the constructor. If this usage occurs in a loop or in a frequently invoked method, millions of String instances can be created needlessly. The improved version is simply the following:

String s = "stringette";

This version uses a single String instance, rather than creating a new one each time it is executed. Furthermore, it is guaranteed that the object will be reused by any other code running in the same virtual machine that happens to contain the same string literal [JLS, 3.10.5].

http://uet.vnu.edu.vn/~chauttm/e-books/java/Effective.Java.2nd.Edition.May.2008.3000th.Release.pdf

Answer 4

With the second method, an object will be created in the heap, but will jvm also create an object in the string pool?

Yes, but it is the string literal "bbb" which ensures the interned string¹. The string constructor creates a new string object which is a copy with the same length and content - the newly created string is not automatically interned.

If that's true, then every time with the new String("bbb");, a object "bbb" is created in the pool, which means by either way above, java will always create a string object in the pool. Then what is intern() used for ?

Only string literals are automatically interned. Other string objects must be manually interned, if such is the desired behavior.

That means there are cases that a string is not in the pool, is that possible ?

With the exception of manual calls to String.intern, only string literals result in interned strings.

While I would recommend using a specialized collection for such cases, interning may be useful where it can be used to avoid creating extra duplicate objects. Some use-cases where interning can be beneficial - as in, the same string value can appear many times - is in JSON keys and XML element/attribute names.

---

¹ This is trivial to reason, consider:

String _b = "bbb";          // string from string literal (this is interned)
String b = new String(_b);  // create a NEW string via "copy constructor"
b == _b           // -> false (new did NOT return an interned string)
b.equals(_b)      // -> true  (but it did return an equivalent string)
b.intern() == _b  // -> true  (which interns to .. the same string object)