JVM for String的存储有一点特殊的地方在于有一块String常量池. This constant pool stores references to String objects.
For example, String s = "abc"会先去String常量池中查找有没有已经存在的引用，如果没有，声明的abc会直接生成一个String对象，并且会在String常量池 stores a reference pointing to this String object.
Strings declared directly after
will also follow the above steps, so the second time String s2 = "abc"从String常量池 finds a reference pointing to the string object declared for the first time.
Andnew String("abc")这样会直接在堆中创建新的对象，不会进入String常量池。要把这样的对象引用放入常量池中就涉及另一个String类的方法intern(), this method returns a constant pool reference of a String object. If this object is not in the constant pool, the String object will be put into the constant pool and the corresponding object reference will be returned.
The first screenshot method of the questionerstr2.intern() == str3.intern()这样使用也会返回true，调用intern()返回的String常量池The reference is the same.
Helps you understand the process. There are a few points in Java that you can remember 1. All strings will be generated in the constant pool, corresponding to CONSTANT_String_info, which is immutable. 2. Ordinary objects are almost always generated in the heap (of course, there are also some special objects such as Class objects that may be generated in the method area. This depends on different virtual machine implementations, and the virtual machine specification is not mandatory) 3.= =When making this determination, for reference types, the final analysis is to compare the memory address.
Okay, now that we have the above concepts. In the first question, String s1 = new String("aaa"); When you create a new object, jvm will help you open up an object space on the heap, and s1 is stored in your local variable table, and s1 points to This object space (can be temporarily understood as the address of the object space stored in s1). So you created two new ones, which are two different object spaces. ==The judgment is of course different, because s1 and s2 point to different spaces.
The second question, the first point above, each string will only exist in one copy in the constant pool, so str2 points to the address of this constant pool string, and str3 also points to the address of this constant pool string. ==The judgment is naturally the same.
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
JVM for
String的存储有一点特殊的地方在于有一块String常量池.This constant pool stores references to String objects.
For example,
Strings declared directly afterString s = "abc"会先去String常量池中查找有没有已经存在的引用，如果没有，声明的abc会直接生成一个String对象，并且会在String常量池stores a reference pointing to this String object.will also follow the above steps, so the second time
String s2 = "abc"从String常量池finds a reference pointing to the string object declared for the first time.And
new String("abc")这样会直接在堆中创建新的对象，不会进入String常量池。要把这样的对象引用放入常量池中就涉及另一个String类的方法intern(), this method returns a constant pool reference of a String object. If this object is not in the constant pool, the String object will be put into the constant pool and the corresponding object reference will be returned.The first screenshot method of the questioner
str2.intern() == str3.intern()这样使用也会返回true，调用intern()返回的String常量池The reference is the same.All non-built-in data types in Java are references.
String s = new String("xx"); This method will create a memory space and make the reference s point to it.
String s = "xx"; This method will make the reference s point to a shared space.
When created using new, str2 and str3 point to different memory spaces, so str2 and str3 are not equal.
When string assignment is used directly, str2 and str3 point to the same memory space, so str2 and str3 are equal.
You can use str2.equals(str3) to compare the contents of strings.
One is to store in the constant pool, and the other is to create new objects in the heap
Helps you understand the process. There are a few points in Java that you can remember
1. All strings will be generated in the constant pool, corresponding to CONSTANT_String_info, which is immutable.
2. Ordinary objects are almost always generated in the heap (of course, there are also some special objects such as Class objects that may be generated in the method area. This depends on different virtual machine implementations, and the virtual machine specification is not mandatory)
3.= =When making this determination, for reference types, the final analysis is to compare the memory address.
Okay, now that we have the above concepts. In the first question,
String s1 = new String("aaa"); When you create a new object, jvm will help you open up an object space on the heap, and s1 is stored in your local variable table, and s1 points to This object space (can be temporarily understood as the address of the object space stored in s1). So you created two new ones, which are two different object spaces. ==The judgment is of course different, because s1 and s2 point to different spaces.
The second question, the first point above, each string will only exist in one copy in the constant pool, so str2 points to the address of this constant pool string, and str3 also points to the address of this constant pool string. ==The judgment is naturally the same.