Changes to String.intern() in Java 7

intern() method of String class is used for internalizing Java String. It's a process of creating a String pool where String objects with equal values are stored only once.
You can look at this post for more details on the method.

There is no change in the contract of the method. So, from the perspective of usage of this method, it's still same. Changes are mainly around the implementation of String pool where interned strings are stored. Let's go in detail :

 

intern() method until Java 6

Until Java 6 (and even some of the early Java 7 releases) all interned strings were stored in PermGen (Permanent Generation) memory. This memory area is reserved for long lived objects such as classes and constant pools. PermGen has fixed size, so it can NOT be expanded at runtime. This means that careless usage of interning strings can result in problem. JVM specification refers to this memory area as Method Area.

 

intern() method in Java 7

String pool in Java 7 was relocated to heap. So method area is logically part of heap, link. This means fixed size limitation of Perm Gen is not an issue any more. So along with normal objects, interned Strings will also get stored in heap.

 

References :

http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html
https://blogs.oracle.com/jonthecollector/entry/presenting_the_permanent_generation
http://java-performance.info/string-intern-in-java-6-7-8/
http://kevinboone.net/java_oddities.html
http://mfinocchiaro.files.wordpress.com/2008/07/java-virtual-machine-neutral.pdf
http://radar.oreilly.com/2011/09/java7-features.html
http://www.infoq.com/news/2013/12/Oracle-Tunes-Java-String
http://java-performance.info/changes-to-string-java-1-7-0_06/

Interning String in Java

String class of Java API has a native method, intern().  This method is used for internalizing Java String. It's a process of creating a String pool where String objects with equal values are stored only once.

Method signature: 
public native String intern()

Straight from Java Doc

Returns a canonical representation for the string object.A pool of strings, initially empty, is maintained privately by the class String.

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.

All literal strings and string-valued constant expressions are interned.

public static void main(String[] args){
        String s = "abc";
        String d = "abc".intern();
        String f = new String("abc").intern();
        String g = new String("abc");
       
        System.out.format("  s == d : %b", (s==d));
        System.out.format("; s == f : %b", (s==f));
        System.out.format("; s == g : %b", (s==g));
        System.out.format("; s.equals(f) : %b", s.equals(f));
        System.out.format("; s.equals(g) : %b", s.equals(g));
    }

Ouptput :  s == d : true; s == f : true; s == g : false; s.equals(f) : true; s.equals(g) : true

So all strings except g in above case are interned.

Related Post : Changes to intern() method in Java 7