Mystry of Java String.intern

Mystery of Java String.intern

We have all learn about how Java has optimised handling string objects. The String class has been made immutable and string literal definition makes sure that existing instance from string pool will be returned instance creating new one.
Here is simple code snippet that explains it

String firstName = "John";
String firstNameWithNew = new String("John");
String duplicateFirstName = "John";

//All there strings are same
System.out.println(firstName.equals(duplicateFirstName) && firstName.equals(firstNameWithNew));//=> true
//Since they defiend using string iterals, even there memory references are same
System.out.println(firstName == duplicateFirstName);//=> true
//Since one of the object has defined explictly using new operator, there memory references are different.
System.out.println(firstName == firstNameWithNew);//=> false

This is very basic understanding that everyone has. Then I came across String.intern() As per java docs

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.

It follows that for any two strings s and t, s.intern() == t.intern() is true if and only if s.equals(t) is true.

When java string literal statement internally takes care of referring any existing same object from pool,

• why do we need explicit function for the same?
• where and how is it going to be used ?

Lets look at below code snippet

String jafullName = "John Andreson";
String jmFullName = "John Miller";

String jaFirstName = jafullName.substring(0, 4);
String jmFirstName = jmFullName.substring(0, 4);

//They have common first name
System.out.println(jaFirstName.equals(jmFirstName)); //=> true

//Are both references same ?
System.out.println(jaFirstName == jmFirstName);//=>False

In above snippet, even if both person’s first name are same, their references are different. Since String is immutable any operations will create new instance instate of updating existing.
If a system process large number of string objects and frequency of many string objects are very high then String pool will full of duplicate objects.

So how do you optimise above code snippet ?

String jafullName = "John Andreson";
String jmFullName = "John Miller";

String jaFirstName = jafullName.substring(0, 4).intern();
String jmFirstName = jmFullName.substring(0, 4).intern();

//They have common first name
System.out.println(jaFirstName.equals(jmFirstName)); //=> true

//Are both references same ?
System.out.println(jaFirstName == jmFirstName);//=> true

Notice the usage of intern in statement #3 & #4, it makes sure that any existing reference get returned if any same content object available in the String pool. This way the program makes sure that no duplicate strings are occupying space in String Pool.

Applications where String.intern matters

1. Cache implementation
2. Application that process/manipulates large number of string objects.