Detailed explanation of intern() in String object

1. First of all, String does not belong to the 8 basic data types. String is an object.
Because the default value of the object is null, the default value of String is also null; but it is a special object and has some characteristics that other objects do not have.

2. New String() and new String("") both declare a new empty string, which is an empty string and not null;

3. String str="kvill";
String str=new String (“kvill”); The difference:

Here, we don’t talk about the heap or the stack, we just simply introduce the constantpool. the concept of.

The constant pool refers to some data that is determined during compilation and saved in the compiled .class file. It includes constants in classes, methods, interfaces, etc., as well as string constants.

Look at Example 1:

String s0=”kvill”; 
String s1=”kvill”; 
String s2=”kv” + “ill”; 
System.out.
print
ln( s0==s1 ); 
System.out.println( s0==s2 );

The result is:

true 
true

First of all, we need to know that Java will ensure that there is only one copy of a string constant.

Because the "kvill" in s0 and s1 in the example are both string constants, they are determined at compile time, so s0==s1 is true; and "kv" and "ill" are also They are all string constants. When a string is concatenated by multiple string constants, it must itself be a string constant, so s2 is also parsed into a string constant at compile time, so s2 is also a constant pool. A quote of "kvill".
So we get s0==s1==s2;
The string created with new String() is not a constant and cannot be determined at compile time, so the string created with new String() does not contain constants In the pool, they have their own address space.

Look at Example 2:

String s0=”kvill”; 
String s1=new String(”kvill”); 
String s2=”kv” + new String(“ill”); 
System.out.println( s0==s1 ); 
System.out.println( s0==s2 ); 
System.out.println( s1==s2 );

The result is:

false 
false 
false

In Example 2, s0 is still the application of "kvill" in the constant pool. Because s1 cannot be determined at compile time, it is a reference to the new object "kvill" created at runtime. Because s2 has the second half of new String ("ill"), it cannot be determined at compile time, so it is also a new Create the application of object "kvill"; if you understand this, you will know why this result is obtained.

4. String.intern():

One more point: the constant pool that exists in the .class file is loaded by the JVM during runtime and can be expanded. The intern() method of String is a method to expand the constant pool; when a String instance str calls the intern() method, Java searches for whether there is a string constant with the same Unicode in the constant pool, and if so, returns its reference. If If not, add a Unicode string equal to str in the constant pool and return its reference; it will be clear by looking at Example 3

Example 3:

String s0= “kvill”; 
String s1=new String(”kvill”); 
String s2=new String(“kvill”); 
System.out.println( s0==s1 ); 
System.out.println( “**********” ); 
s1.intern(); 
s2=s2.intern(); //把常量池中“kvill”的引用赋给s2 
System.out.println( s0==s1); 
System.out.println( s0==s1.intern() ); 
System.out.println( s0==s2 );

The result is:

false 
********** 
false //虽然执行了s1.intern(),但它的返回值没有赋给s1 
true //说明s1.intern()返回的是常量池中”kvill”的引用 
true

Finally, I will dispel another misunderstanding:

Someone said, "Use the String.intern() method to save a String class into a global String table. If a Unicode string with the same value is already in this table, then this method returns the address of the string already in the table. If there is no string with the same value in the table, register its own address into the table. "If I If we interpret the global String table he mentioned as a constant pool, his last sentence, "If there is no string with the same value in the table, register your own address in the table" is wrong:

Look at Example 4:

String s1=new String("kvill"); 
String s2=s1.intern(); 
System.out.println( s1==s1.intern() ); 
System.out.println( s1+" "+s2 ); 
System.out.println( s2==s1.intern() );

Result:

false 
kvill kvill 
true

We did not declare a "kvill" constant in this class, so there was no constant in the constant pool at the beginning. "kvill", when we call s1.intern(), a new "kvill" constant is added to the constant pool. The original "kvill" that is not in the constant pool still exists, which means it is not "registering its own address" into the constant pool".

s1==s1.intern() is false, indicating that the original "kvill" still exists;

s2 is now the address of "kvill" in the constant pool, so s2==s1. intern() is true.

5. About equals() and ==:

For String, this is simply to compare whether the Unicode sequences of two strings are equivalent, and return true if they are equal; while == compares two strings. Whether the addresses of the strings are the same, that is, whether they are references to the same string.

6. There is a lot to say about String being immutable. As long as you know that a String instance will not change once it is generated, for example: String str=" kv"+"ill"+" "+"ans";
There are 4 string constants. First, "kv" and "ill" generate "kvill" and store it in the memory, and then "kvill" and " " Generate "kvill" and store it in the memory, and finally generate "kvill ans"; and assign the address of this string to str, because the "immutability" of String generates many temporary
variables
, This is why it is recommended to use StringBuffer, because StringBuffer is changeable
[Related recommendations]

1. Java free video tutorial

2. In-depth analysis of the intern() method in Java

3. JAVA Summary of experience in using intern() method

4. What is the concept of intern method in java

5. Analysis of intern in Java The function of ()

The above is the detailed content of Detailed explanation of intern() in String object. For more information, please follow other related articles on the PHP Chinese website!