WHAT IS THE NEED FOR STRING INTERN() FUNCTION

String interning – Storing only one copy of each distinct String value

It is a process by which String object is moved to String Pool

String can be created by 2 ways

• String literal   –> String  car = “Bmw”;
• String object  –> String bike= new String(“ThunderBird”);

Java maintains a pool of interned string object references. When the intern() is called on a String object , the pool is checked if a string object with the same value exists. If it does then the reference of the existing object is returned. Else a new object is created and its reference is added in to the intern pool.

String literal

• String created using String literal are automatically interned
• It is stored in Permanent generation memory area.
• car object will be created,its reference  will be stored in String pool and it will be automatically interned
• String car1=”Bmw”;String car2 = “Bmw”;
• car1 = =car2==car3. All three will be pointing to same object

String Object

• String created using new object should be explicitly interned
• They will be stored under Java Heap Memory
• String bike1= new String(“ThunderBird”);String bike2= new String(“ThunderBird”);
• bike,bike1 & bike2 will be pointing to 3 different string objects in Java Heap Memory
• To make them point to same object they need to be interned explicitly
• String bike4 = bike.intern(); This will first check if there is a object in String pool with the same value .  Since bike is originally created in Java heap memory it will return false as it is not available in the String intern pool.  Now it will create a object in the String pool and return the reference
• Now if we check if bike4 == bike it will return false. Because bike4 is in string pool and bike is in object pool
• To avoid this we need to do something like this; String bike = new String (“ThunderBird”);bike = bike.intern();

Things to note

• s1.intern() == s2.intern() only if s1.equals(s2)
• For interned strings we can use == for comparison as we know that value of its references will always be the same.
• Use interned strings when your usecase involves lot of string comparison. Using == is much faster then .equals() method.
• Mostly used in HashKey comparison.
• Saves space as multiple copy of same string will be pointing to the same object.

Dis-advantages

• Remember to intern all string objects that would be compared
• Maintains a pool of interned Strings
• Creation time increases as it compares against the interned pool before allocating the reference.
• Pre-Java7 Intern pool is maintained in Permanent Gen Mem area which has the restriction on size, which can lead to OutOfMemoryError:PermGen Space
• From Java 7 onward it is moved to Java Heap Memory

---