Java- Creating String object using new keyword

I know the difference between String literal and new String object and also know how it works internally. My question is a little bit advance of this. When we create String object using new keyword as

String str = new String("test");

In this case, we are passing a argument of String type. Where does this string get generated, heap or string constant pool or somewhere else?

As to my knowledge, this argument is a string literal, so it should be in String constant pool. If it is so, then what is use of the intern method, only just link variable str to constant pool? because "test" would be available already.

Please clarify me, if I had misunderstood the concept.

The statement String str = new String("test"); creates a string object which gets stored on the heap like any other object. The string literal "test" that is passed as an argument is stored in the string constant pool.

String#intern() checks if a string constant is already available in the string pool. If there is one already it returns it, else it creates a new one and stores it in the pool. See the Javadocs:

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.

Starting from JDK7, interned strings are stored on the heap. This is from the release notes of JDK7:

In JDK 7, interned strings are no longer allocated in the permanent generation of the Java heap, but are instead allocated in the main part of the Java heap (known as the young and old generations), along with the other objects created by the application. This change will result in more data residing in the main Java heap, and less data in the permanent generation, and thus may require heap sizes to be adjusted. Most applications will see only relatively small differences in heap usage due to this change, but larger applications that load many classes or make heavy use of the String.intern() method will see more significant differences.