Explication détaillée du pool de constantes de chaîne en Java

Cet article vous apporte une explication détaillée du pool de constantes de chaîne en Java. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

En tant que type de données de référence le plus basique, les concepteurs Java fournissent un pool de constantes de chaîne pour String afin d'améliorer ses performances. Alors, quel est le principe spécifique du pool de constantes de chaîne ? pour comprendre le pool de constantes de chaîne :

Quelle est l'intention de conception du pool de constantes de chaîne ?

Où se trouve le pool de constantes de chaîne ?

Comment faire fonctionner le pool de constantes de chaîne ?

L'idée de conception du pool de constantes de chaînes

a L'allocation de chaînes, comme les autres allocations d'objets, prend du temps. et Le coût de l'espace, en tant que type de données le plus élémentaire, consiste à créer fréquemment un grand nombre de chaînes, ce qui affecte grandement les performances du programme.

b. Afin d'améliorer les performances et de réduire la surcharge de mémoire, la JVM a effectué quelques optimisations lors de l'instanciation des constantes de chaîne.

Ouvrez un pool de constantes de chaîne pour les chaînes, similaire à une zone de cache.

Lors de la création d'une constante de chaîne, vérifiez d'abord si la chaîne existe dans le pool de constantes de chaîne.

Si la chaîne existe, renvoyez l'instance de référence. Si elle n'existe pas, instanciez la chaîne et placez-la dans le pool.

c. Base de mise en œuvre

La base de mise en œuvre de cette optimisation est que les chaînes sont immuables et peuvent être partagées sans se soucier des conflits de données.

Il existe une table dans le pool de constantes de chaîne globale créé par l'instance d'exécution, qui maintient toujours une référence pour chaque objet de chaîne unique dans le pool, ce qui signifie qu'ils font toujours référence au pool de constantes de chaîne. donc ces chaînes dans le pool constant ne seront pas recyclées par le garbage collector.

Code : Obtenez la chaîne correspondante du pool de constantes de chaîne

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

Où se trouve le pool de constantes de chaîne

Lors de l'analyse de l'emplacement du pool de constantes de chaîne, comprenez d'abord la zone du tas, de la pile et de la méthode :

Tas

Objets sont stockés et chaque objet contient une classe correspondante

La JVM n'a qu'une seule zone de tas (tas) partagée par tous les threads. Les types de base et les références d'objet ne sont pas stockés dans le tas, seul l'objet lui-même

Les objets sont recyclés par le garbage collector, donc la taille et le cycle de vie n'ont pas besoin d'être déterminés

Pile

Chaque thread contient une zone de pile, la pile Seuls les objets de types de données de base et les références à des objets personnalisés (pas des objets) sont enregistrés dans

Les données (types primitifs et références d'objet) dans chaque pile sont privées

La pile est divisée en 3 parties : zone de variable de type de base, contexte d'environnement d'exécution, zone d'instructions d'opération (instructions d'opération de stockage)

La taille et le cycle de vie des données peuvent être déterminés. Lorsqu'il n'y a aucune référence aux données, les données disparaîtront automatiquement.

Zone de méthode

La zone statique, comme le tas, est partagée par tous les threads

Ce qui est inclus dans la zone de méthode est utilisé pour toujours dans le programme entier Les seuls éléments, tels que la classe, les variables statiques

, le pool de constantes de chaîne existe dans la zone de méthode

Code : La zone de méthode de pile stocke les chaînes

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

Création d'objets chaîne

Question d'entretien : Combien d'objets sont créés par String str4 = new String("abc" ) ?

1. Recherchez s'il existe un objet "abc" dans le pool de constantes

S'il y en a, renvoyez l'instance de référence correspondante

Sinon, créez l'objet d'instance correspondant

2. Créez un nouvel objet String("abc") dans le tas

3. Attribuez l'adresse de l'objet à str4 et créez une référence

Donc, il n'y a pas Littéral "abc" dans le pool constant Créez ensuite deux objets, sinon créez un objet et créez une référence

Sur la base du littéral, une telle variante de question est souvent posée :

String str1 = new String("A"+ "B") ; Combien d'objets seront créés ?

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

str1 :
caractères Pool de constantes de chaîne : "A", "B", "AB": 3
Tas : new String("AB") : 1
Référence : str1 : 1
Total : 5

str2 :
Pool de constantes de chaîne : "ABC": 1
Tas : new String("ABC") : 1
Référence : str2 : 1
Total : 3

codes : variables et constantes de type de base, les variables et les références sont stockées sur la pile, et les constantes sont stockées dans le pool de constantes

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

Comment faire fonctionner le pool de constantes de chaîne

Lorsque la JVM instancie le pool de constantes de chaîne

  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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!