Detaillierte Erläuterung des String-Konstantenpools in Java

Dieser Artikel enthält eine detaillierte Erklärung des String-Konstantenpools in Java. Ich hoffe, dass er für Freunde hilfreich ist.

Als grundlegendster Referenzdatentyp stellen Java-Designer einen String-Konstantenpool zur Verfügung, um dessen Leistung zu verbessern. Was ist also das spezifische Prinzip des String-Konstantenpools? Wir haben die folgenden drei Fragen: Um den String-Konstanten-Pool zu verstehen:

Was ist die Entwurfsabsicht des String-Konstanten-Pools?

Wo ist der String-Konstantenpool?

Wie betreibe ich den String-Konstantenpool?

Die Designidee des String-Konstantenpools

a Die Zuweisung von Strings ist wie andere Objektzuweisungen zeitaufwändig Da es sich um den grundlegendsten Datentyp handelt, ist es teuer, häufig eine große Anzahl von Zeichenfolgen zu erstellen, was sich stark auf die Leistung des Programms auswirkt.

b. Um die Leistung zu verbessern und den Speicheraufwand zu reduzieren, hat die JVM einige Optimierungen bei der Instanziierung von String-Konstanten vorgenommen.

Öffnen Sie einen String-Konstantenpool für Strings, ähnlich einem Cache-Bereich.

Überprüfen Sie beim Erstellen einer Zeichenfolgenkonstante zunächst, ob die Zeichenfolge im Zeichenfolgenkonstantenpool vorhanden ist.

Wenn die Zeichenfolge vorhanden ist, geben Sie die Referenzinstanz zurück. Wenn sie nicht vorhanden ist, instanziieren Sie die Zeichenfolge und fügen Sie sie in den Pool ein.

c. Grundlage der Implementierung

Die Grundlage für die Implementierung dieser Optimierung ist, dass Zeichenfolgen unveränderlich sind und geteilt werden können, ohne sich Gedanken über Datenkonflikte machen zu müssen.

Im von der Laufzeitinstanz erstellten globalen String-Konstantenpool gibt es eine Tabelle, die immer eine Referenz für jedes eindeutige String-Objekt im Pool verwaltet, was bedeutet, dass sie immer auf den String-Konstantenpool verweisen. Daher werden diese Zeichenfolgen im konstanten Pool vom Garbage Collector nicht recycelt.

Code: Holen Sie sich die entsprechende Zeichenfolge aus dem String-Konstantenpool

  String str1 = “hello”;
  String str2 = “hello”;
  System.out.printl（"str1 == str2" : str1 == str2 ) //true

Wo ist der String-Konstantenpool

Bei der Analyse Um den Speicherort des String-Konstantenpools zu ermitteln, verstehen Sie zunächst den Heap, den Stapel und den Methodenbereich:

Heap

gespeichert Es ist ein Objekt. Jedes Objekt enthält eine entsprechende Klasse

Die JVM verfügt nur über einen Heap-Bereich (Heap), der von allen Threads gemeinsam genutzt wird. Der Heap speichert keine Basistypen und Objektreferenzen, sondern nur das Objekt selbst

Das Objekt wird vom Garbage Collector recycelt, sodass Größe und Lebenszyklus nicht bestimmt werden müssen

Stapel

Jeder Thread enthält einen Stapelbereich und den Nur Stapel. Speichern Sie Objekte grundlegender Datentypen und Verweise auf benutzerdefinierte Objekte (keine Objekte).

Die Daten in jedem Stapel (primitive Typen und Objektreferenzen) sind privat.

Der Stapel ist in drei Teile unterteilt : Basistyp-Variablenbereich, Ausführungsumgebungskontext, Betriebsanweisungsbereich (Speicherbetriebsanweisungen)

Die Datengröße und der Lebenszyklus können bestimmt werden. Wenn kein Verweis auf die Daten vorhanden ist, verschwinden die Daten automatisch.

Methodenbereich

Der statische Bereich wird wie der Heap von allen Threads gemeinsam genutzt

Was im Methodenbereich enthalten ist, ist im gesamten Programm immer eindeutig Im Methodenbereich sind Elemente wie Klasse, statische Variablen

und String-Konstantenpools vorhanden

Code: Der Stack-Methodenbereich speichert Strings

String str1 = “abc”;
String str2 = “abc”;
String str3 = “abc”;
String str4 = new String(“abc”);
String str5 = new String(“abc”);

Erstellung von String-Objekten

Interviewfrage: Wie viele Objekte werden durch String str4 = new String("abc") erstellt?

1. Finden Sie heraus, ob sich im Konstantenpool ein „abc“-Objekt befindet.

Wenn ja, geben Sie die entsprechende Referenzinstanz zurück.

Wenn nicht, erstellen Sie das entsprechende Instanzobjekt

2. Erstellen Sie ein neues String("abc")-Objekt im Heap

3. Weisen Sie str4 die Objektadresse zu und erstellen Sie eine Referenz

Es gibt also keine „abc“-Literal im Konstantenpool Erstellen Sie dann zwei Objekte, andernfalls erstellen Sie ein Objekt und erstellen Sie eine Referenz

Basierend auf dem Literal wird häufig eine solche Variantenfrage gestellt:

String str1 = new String("A"+ "B") ; Wie viele Objekte werden erstellt?

String str2 = new String("ABC") + "ABC" ;

str1:

Zeichen String-Konstantenpool: "A", "B", "AB": 3
Heap: new String("AB"): 1
Referenz: str1: 1
Gesamt: 5

str2:

String-Konstantenpool: „ABC“: 1
Heap: neuer String(“ABC“): 1
Referenz: str2: 1
Gesamt : 3

Codes: Basistypvariablen und -konstanten, Variablen und Referenzen werden auf dem Stapel gespeichert und Konstanten werden im Konstantenpool

int a1 = 1;
int a2 = 1;
int a3 = 1;
public static int INT1 =1 ;
public static int INT2 =1 ;
public static int INT3 =1 ;

< gespeichert 🎜>

So bedienen Sie den String-KonstantenpoolWenn die JVM den String-Konstantenpool instanziiert

  String str1 = “hello”;
  String str2 = “hello”;
  System.out.printl（"str1 == str2" : str1 == str2 ) //true

String.intern()

通过new操作符创建的字符串对象不指向字符串池中的任何对象，但是可以通过使用字符串的intern()方法来指向其中的某一个。java.lang.String.intern()返回一个保留池字符串，就是一个在全局字符串池中有了一个入口。如果以前没有在全局字符串池中，那么它就会被添加到里面

// Create three strings in three different ways.
    String s1 = "Hello";
    String s2 = new StringBuffer("He").append("llo").toString();
    String s3 = s2.intern();
    // Determine which strings are equivalent using the ==
    // operator
    System.out.println("s1 == s2? " + (s1 == s2)); // false
    System.out.println("s1 == s3? " + (s1 == s3)); // true

字面量和常量池初探

字符串对象内部是用字符数组存储的，那么看下面的例子:

String m = "hello,world";
String n = "hello,world";
String u = new String(m);
String v = new String("hello,world");

1.会分配一个11长度的char数组，并在常量池分配一个由这个char数组组成的字符串，然后由m去引用这个字符串

2.用n去引用常量池里边的字符串，所以和n引用的是同一个对象

3.生成一个新的字符串，但内部的字符数组引用着m内部的字符数组

4.同样会生成一个新的字符串，但内部的字符数组引用常量池里边的字符串内部的字符数组，意思是和u是同样的字符数组

使用图来表示的话，情况就大概是这样的(使用虚线只是表示两者其实没什么特别的关系):

测试demo：

 String m = "hello,world";        
 String n = "hello,world";        
 String u = new String(m);        
 String v = new String("hello,world");        
 System.out.println(m == n); //true         
 System.out.println(m == u); //false        
 System.out.println(m == v); //false        
 System.out.println(u == v); //false

结论：

m和n是同一个对象

m,u,v都是不同的对象

m,u,v,n但都使用了同样的字符数组，并且用equal判断的话也会返回true

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des String-Konstantenpools in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!