当调用string intern（）方法时

Question

Case 1:

  String str = "StackOverFlow"; String str1 = "StackOverFlow"; if(str==str1){ System.out.println("equal");//prints equal } 

Case 2:

  String str = "StackOverFlow"; String str1=str.intern(); if(str==str1){ System.out.println("equal");//prints equal } 

follow up questions:

1. I want to know whether for the first case JVM calls intern() internally and assign the reference of str to str1 ?

2. how two references equal in the first case?

3. Does the first case means whenever you declare a string like String str = "StackOverFlow"; it adds to the pool of string as same as that of intern() method?

4. Does String pool which is used by String str = "StackOverFlow"; and intern() is allocated outside of heap? if yes where exactly?

---

For question 4 the answer is as below:

In Java 6 and earlier, interned strings were also stored in the permanent generation. In Java 7, interned strings are stored in the main object heap.

Here is what documentation says:

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.

Further details from here:

String.intern() in Java 6

In those good old days all interned strings were stored in the PermGen – the fixed size part of heap mainly used for storing loaded classes and string pool. Besides explicitly interned strings, PermGen string pool also contained all literal strings earlier used in your program (the important word here is used – if a class or method was never loaded/called, any constants defined in it will not be loaded).

 The biggest issue with such string pool in Java 6 was its location – the PermGen. PermGen has a fixed size and can not be expanded at 

runtime. You can set it using -XX:MaxPermSize=96m option. As far as I know, the default PermGen size varies between 32M and 96M depending on the platform. You can increase its size, but its size will still be fixed. Such limitation required very careful usage of String.intern – you'd better not intern any uncontrolled user input using this method. That's why string pooling at times of Java 6 was mostly implemented in the manually managed maps.

String.intern() in Java 7

Oracle engineers made an extremely important change to the string pooling logic in Java 7 – the string pool was relocated to the heap. It means that you are no longer limited by a separate fixed size memory area. All strings are now located in the heap, as most of other ordinary objects, which allows you to manage only the heap size while tuning your application. Technically, this alone could be a sufficient reason to reconsider using String.intern() in your Java 7 programs. But there are other reasons.

Answer 1

The references are equal because they are both String literals.

The intern() call on str is not needed because it is also a literal. An example of when you would need to use intern() (which, by the way is a lot slower then equals() , so don't use it) would be when constructing a String with a byte or char array.

For example:

final String str1 = "I am a literal";
final String str2 = new String(str1.toCharArray());

final boolean check1 = str1 == str2;          // false
final boolean check2 = str1 == str2.intern(); // true

Answer 2

1) I want to know whether for the first case JVM calls intern() internally and assign the reference of str to str1?

Well, yes and no.

Yes the intern() method is called internally. But the call doesn't happen when that code is run. In fact, it happens when that code is loaded . The loader then saves the reference to the interned String.

But in this case, the loading process only needs to do the interning once. The two literals (in this case) will actually be represented by a single "constant pool entry" in the class that is being loaded. (The Java compiler will have spotted the duplicate literals in the class ... at compile time ... and eliminated it.)

2) how two references equal in the first case?

Because the two strings have been interned.

3) Does the first case means whenever you declare a string like String str = "StackOverFlow"; it adds to the pool of string as same as that of intern() method?

Yes ... modulo that the interning doesn't happen at the point when the code containing the declaration is run.

4) Does String pool which is used by String str = "StackOverFlow"; and intern() is allocated outside of heap? if yes where exactly?

The answer is somewhat system dependent. In general, the string pool is in the heap. On some systems the heap is divided into regions or spaces which have different garbage collection policies, and the string pool is allocated in the so-called "permgen" space that is sized independently of the rest of the heap. But this is not always true.

Answer 3

I want to know whether for the first case JVM calls intern() internally

No.

and assign the reference of str to str1?

Yes, but because the value is a literal, not because of interning. There is only one instance of it in the .class file in the first place.

how two references equal in the first case?

That's not another question, just the same question re-stated.

Does the first case means whenever you declare a string like String str = "StackOverFlow"; it adds to the pool of string as same as that of intern() method?

Yes, but it's done by the compiler, not intern().

Does String pool which is used by String str = "StackOverFlow"; and intern() is allocated outside of heap?

No.

where exactly?

In the constant pool of the loaded class, which is in the heap.

Answer 4

There are largely 2 ways of creating string objects.

One is

String str = "test-String"; // This string is created in string pool or returned from
string pool if already exists

Second one

String str = new String("test-string");// This string object will be created in heap memory and will be treated as any other object

When you call string.intern on the string instance created using new operator... this string will be created in string-pool or returned from the pool if exists. This is a mechanism to move the string object from heap to perm Gen (String pool)