How does Java's intern() method behave on such Strings that are created during run time

class Demo
{  
    public static void main(String[] args)  
    {  
        String s1 = new String("ABC");
        String s2 = s1.concat("ABC");
        String s3 = s2.intern();
        System.out.println(s2 == s3); //true

        String s4 = "ABCABC";
        System.out.println(s3 == s4); //true
    }  
}

String s2 = s1.concat("ABC"); would create a new String object "ABCABC" on the heap area.
String s3 = s2.intern(); should create a new String object onto the String constant pool.

Since these are two different objects, their references shouldn't be equal. But seems that i'm missing out on something important related to intern().

From the docs of intern:

> 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.

Before intern is called, the string ABCABC is actually already in the string pool! And according to the above, if the string is already in the pool, intern just returns the string from the pool, rather creating a duplicated string in the pool. This is the same instance as the string created from a literal in your code.

"Why is the string already in the pool?" I hear you ask. This is because strings are not added to the string pool when they first appear in the source code. The compiler collects all the string literals in the source code, and puts them in the class file. All the strings in the class file are put into the string pool when your program begins running.

To actually see the behaviour that you expect, you must not use the string literal "ABCABC". For example, you can replace it with "ABC".concat("ABC"):

String s4 = "ABC".concat("ABC"); // this creates a new string

From javadoc:

> 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. String literals are defined in section 3.10.5 of the The Java™ Language Specification.

So the internal string pool for your code evolve as follow:

public static void main(String[] args)  
{
    String s1 = new String("ABC");  
    // "ABC" generate a new string and add it to intern pool.
    // new String("ABC") uses the already present ABC string to generate a new copy that is not present in the pool. 
    // s1 points to that string that is not present in the internal pool
   

    String s2 = s1.concat("ABC"); 
    // "ABC" is already present. s1.concat("ABC") creates a new string ABCABC that is added to the internal pool. s2 point to that string   

    String s3 = s2.intern();         
    // s2.intern() returns a pointer to ABCABC that is already present in the internal pool. s3 points to that string


   System.out.println(s2 == s3);
   // Prints true because ABCABC present in the internal pool is pointed by both s2 and s3.

    String s4 = "ABCABC";
    // ABCABC is already present in the internal pool. s4 points to that string

    System.out.println(s3 == s4);  
    // Prints true because all s2, s3, s4 points to the same instance ABCABC present in the internal pool.
}  

In my opinion,The intern method add the string into String constant pool if there is not the string,and then return the String reference.

so, s4="ABCABC" aready has existed the String pool