Please explain the function of the intern () method

Question

Possible duplicate:
When should we use the intern method for String?
What is string interning?

Please explain the inner workings of the following code:

System.out.println(new String("ABC").intern()==new String("ABC").intern()); 

In the above code, it prints "true". But according to java rules, in the case of a new operator, it always creates a new object. object.intern() method also creates an object in the row pool. So my question is what in the above code is the number of objects created.

According to my words, 3 new objects will be created. One goes to the row pool, and a new anonymous object will be created by the new statement. But I'm not sure.

If I am wrong, explain.

Answer 1

Assuming there is no trick in the optimizer, two objects are created. (A simplified enough optimizer can optimize this to an unconditional true , in which case no objects are created.)

tl; dr version:. You were almost right with your answer 3, except that the row that is part of the row pool is not generated as part of this statement; it is already created.

First, let me get the letter "ABC" . It is presented at run time as a String object, but it lives in a pergene and was created once in the life of the JVM. If this is the first class that uses this string literal, it was created at the time the class was loaded (see JLS 12.5 , which states that String was created when the class was loaded, unless it existed previously).

So, the first new String("ABC") creates a single String that simply copies the link (but does not create a new object) to an array of characters and a hash from the string that represents the literal "ABC" (which, again, is not created as part this line). Then the .intern() method checks to see if the equal String is already in permgen. This (this is just a string that represents a literal to start with) to return this function. So new String("ABC").intern() == "ABC" . See JLS 3.10.5 and in particular:

In addition, a string literal always refers to the same instance of the String class. This is because string literals, or, more generally, strings that are constant expression values ​​(§15.28), are “interned” to exchange unique instances using the String.intern method.

The same thing happens with the second occurrence of new String("ABC").intern() . And since both intern() methods return the same object as the "ABC" literal, they represent the same value.

A little break:

 String a = new String("ABC"); // a != "ABC" String aInterned = a.intern(); // aInterned == "ABC" String b = new String("ABC"); // b != "ABC" String bInterned = b.intern(); // bInterned == "ABC" System.out.println(new String("ABC").intern()==new String("ABC").intern()); // ... is equivalent to... System.out.println(aInterned == bInterned); // ...which is equivalent to... System.out.println("ABC" == "ABC"); // ...which is always true. 

Answer 2

When you call the intern() method, jvm checks to see if a given row exists in the row pool or not. If it is, it will return a link to it, otherwise it will create a new row in the pool and return a link to it. In your case: System.out.println(new String("ABC").intern()==new String("ABC").intern());

The first new String("ABC").intern() will create the string "ABC" in the pool. When you call new String("ABC").intern() second time, jvm will return a link to the previously created string. It is for this reason that you get true when comparing both (btn point to the same link).

Answer 3

I believe that you are right, because the new operation creates a new object, so there are 2 anonymous objects, and intern() creates a new line in the row pool only if it is not already specified and returns a link