Explorez la piscine constante de Java en profondeur

La piscine constante de Java est généralement divisée en deux types: piscine constante statique et piscine constante d'exécution

Pool constant statique: un pool constant dans le fichier de classe. Le pool constant du fichier de classe comprend des valeurs littérales de chaîne (numéro), des informations de classe et de méthode, occupant la majeure partie de l'espace dans le fichier de classe.

Pool constant d'exécution: Une fois le JVM terminé le chargement de la classe, il charge le pool constant dans le fichier de classe en mémoire et l'enregistre dans la zone de la méthode. Ce dont nous parlons habituellement, c'est le pool constant du pool constant d'exécution dans la zone de la méthode. Une autre caractéristique importante de son pool constant par rapport au fichier de classe est sa dynamicité. La langue Java ne nécessite pas de constantes pour être générées uniquement pendant la période de compilation, c'est-à-dire que le contenu du pool constant dans le fichier de classe peut entrer dans le pool constant de la zone d'exécution de la zone de méthode. Pendant la course, de nouvelles constantes peuvent également être placées dans la piscine. Cette fonctionnalité est plus couramment utilisée par les développeurs. La méthode inter () de la classe de chaîne.

Compteur du programme: est un pipeline pour l'exécution du programme, indiquant quelle commande exécuter ensuite.

Pile de méthode locale: la pile utilisée par JVM pour appeler les méthodes du système d'exploitation.

Pile de machine virtuelle: la pile utilisée par JVM pour exécuter le code Java

Tas de machine virtuelle: où les objets sont stockés, et tous les objets qui sont nouveaux dans les programmes Java sont stockés dans le tas.

Zone de méthode: Constantes de stockage, informations de classe et variables statiques, qui peuvent être comprises comme l'emplacement où le fichier de classe est stocké en mémoire.

Avantages de la mise en commun constante:

Des pools constants sont utilisés pour éviter la création et la destruction fréquentes d'objets qui affectent les performances du système, et ils réalisent le partage d'objets.

Par exemple, un pool constant de chaîne est utilisé pour mettre tous les littéraux de chaîne dans un pool constant pendant l'étape de compilation.

1. Enregistrer l'espace mémoire: toutes les constantes de cordes avec la même valeur littérale dans le pool constant sont fusionnées, ne prenant qu'un seul espace

2. Enregistrer le temps d'exécution: lors de l'exécution de comparaisons de chaînes, == est plus rapide que equals (). Pour deux variables de référence, utilisez simplement == pour déterminer si les références sont égales, vous pouvez donc déterminer si les valeurs réelles sont égales.

== Les significations des types de données de base et des représentations d'objets sont différentes.

Pour le type de données de base: == La comparaison est la valeur du type de données de base pour l'objet: == La comparaison est l'adresse mémoire de l'objet en mémoire

8 Types de données de base Classes d'emballage et pools constants

La plupart des classes en wrapper de types de données de base en Java implémentent des technologies de mise en commun constantes, à savoir octet, court, entier, long, caractère et booléen.

 Entier i1 = 40; entier i2 = 40; System.out.println (i1 == i2); // true

Octet, court, entier, long, caractère, ces cinq classes de wrapper créent des données de cache du type correspondant de [-128, 127] par défaut et les stockent dans le pool constant. S'il dépasse cette plage, un nouvel objet sera toujours créé.

 Valeur entière statique publique (int i) {Assert IntegerCache.high> = 127; if (i> = IntegerCache.low && i <= IntegerCache.high) return IntegerCache.cache [i + (-IntegerCache.low)]; retourner un nouvel entier (i); }

 Entier i1 = 400; entier i2 = 400; System.out.println (i1 == i2); // false

2. Les deux types de classes d'emballage du numéro à virgule flottante flottent et ne mettent pas en œuvre une technologie de mise en commun constante.

 Double d1 = 2,5; double d2 = 2,5; System.out.println (d1 == d2); // false

3. Scénarios pour appliquer des pools constants

(1) .Integeri1 = 40; Étant donné qu'Integer est une classe de wrapper du type de données de base INT et est un objet, Java effectuera des opérations de boxe automatique lors de la compilation et résume directement le code dans Integeri1 = Integer.Valueof (40), en utilisant ainsi des objets dans le pool constant

(2) .Integeri1 = NewInteger (40); Dans ce cas, un nouvel objet sera créé

 Entier i1 = 40; entier i2 = nouvel entier (40); System.out.println (i1 == i2); // false

Dans ce cas, un nouvel entier n'effectuera pas les constantes de référence de boxe automatique dans le pool constant, mais générera directement un nouvel objet dans le tas.

4. Détails entiers

 Entier i1 = 40; Entier I2 = 40; Entier i3 = 0; Entier i4 = nouvel entier (40); Entier i5 = nouvel entier (40); Entier i6 = nouvel entier (0); Entier i7 = 128; Entier i8 = 128; System.out.println ("i1 = i2" + (i1 == i2)); System.out.println ("i1 = i2 + i3" + (i1 == i2 + i3)); System.out.println ("i1 = i4" + (i1 == i4)); System.out.println ("i4 = i5" + (i4 == i5)); System.out.println ("i4 = i5 + i6" + (i4 == i5 + i6)); System.out.println ("40 = i5 + i6" + (40 == i5 + i6)); System.out.println ("i7 = i8" + (i7 == i8));

 i1 = i2 trueI1 = i2 + i3 trueI1 = i4 falsei4 = i5 falsei4 = i5 + i6 true40 = i5 + i6 trueI7 = i8 false

Explication: L'énoncé I4 == i5 + i6, car l'opérateur + n'est pas applicable aux objets entiers. Tout d'abord, i5 et i6 effectuent des opérations de déballage automatique et ajoutent des valeurs, c'est-à-dire i4 == 40. Ensuite, l'objet entier ne peut pas être directement comparé à la valeur numérique, donc i4 déborte automatiquement et convertit en valeur int 40. Enfin, cette instruction est convertie en 40 == 40 pour une comparaison numérique.

Classe de cordes et piscine constante

1.Comment créer un objet String

 String S1 = "ABDCD"; String S2 = Nouvelle String ("ABCD"); System.out.println (S1 == S2); // FALSE

Il existe des différences dans les méthodes de création de ces deux manières différentes. La première consiste à prendre des objets dans le pool constant, et le second est de créer de nouveaux objets dans l'espace mémoire du tas.

Utilisez simplement de nouveaux objets seront créés dans le tas.

2. Expression de connexion +

(1). Seuls les nouveaux objets générés par la connexion "+" entre les objets de chaîne créés à l'aide de "" contenant du texte seront ajoutés au pool constant de chaîne.

(2). Pour d'autres formulaires tels que deux références d'objets qui sont directement connectées via "+" ou des objets créés via un nouveau mode, les nouveaux objets résultants ne seront pas ajoutés au pool constant de chaîne.

 String str1 = "str"; string str2 = "ing"; String str3 = "str" ​​+ "ing"; String str4 = str1 + str2; system.out.println (str3 == str4); // false string str5 = "string"; system.out.println (str3 == str5); // true

 chaîne finale statique publique a = "ab"; // String final statique statique constant constant b = "CD"; // constant bpublic static void main (string [] args) {String s = a + b; // Initialise s avec + String de concaténation t = "ABCD"; if (s == t) {System.out.println ("S est égal à T, ils sont le même objet"); } else {System.out.println ("s n'égal pas t, ils ne sont pas le même objet"); }} s est égal à T, ils sont le même objet

A et B sont les deux constantes, et les valeurs sont fixes, donc la valeur de S est également fixe, ce qui est déterminé lorsque la classe est compilée. En d'autres termes: chaîne s = a + b; équivalent à: string s = ”ab” + ”cd”;

 chaîne finale statique publique a; // String final statique statique constant B; // BSTATIC constant {a = "ab"; B = "cd"; } public static void main (String [] args) {// initialiser s avec + concaténation String s = a + b; String t = "ABCD"; if (s == t) {System.out.println ("S est égal à T, ils sont le même objet"); } else {System.out.println ("s n'égal pas t, ils ne sont pas le même objet"); }} s n'est pas égal à t, ils ne sont pas le même objet

Bien que A et B soient définis comme des constantes, aucun d'eux n'est attribué immédiatement. Avant de calculer la valeur de S, lorsqu'ils sont attribués et la valeur qui leur est attribuée sont des variables. Par conséquent, avant que A et B ne soient attribués, leurs propriétés sont similaires à une variable. Ensuite, S ne peut pas être déterminé pendant la période de compilation, mais ne peut être créé qu'au moment de l'exécution.

3.Strings1 = Newsring ("xyz"); Combien d'objets ont été créés?

Considérez la phase de chargement de classe et l'exécution réelle.

(1) La charge de classe ne sera effectuée qu'une seule fois sur une classe. "XYZ" est créé et résidé lorsque la classe est chargée (si la chaîne "xyz" a été résidée avant le chargement de la classe, il n'est pas nécessaire de créer à plusieurs reprises l'instance "xyz" pour résider). La chaîne résidée est placée dans un pool constant de chaîne partagé globalement.

(2) Lorsque ce code est ensuite exécuté, l'instance de chaîne correspondant au littéral "xyz" est fixe et ne sera pas créée à plusieurs reprises. Ainsi, ce code copie une copie de l'objet dans le pool constant et le place dans le tas, et remet la référence à l'objet dans le tas de S1 à maintenir.

Cette déclaration crée 2 objets.

4.java.lang.string.intern ()

Une autre caractéristique importante du pool constant d'exécution par rapport au pool constant du fichier de classe est sa dynamicité. La langue Java ne nécessite pas de constantes pour être générées uniquement pendant la période de compilation, c'est-à-dire que le contenu du pool constant dans le fichier de classe peut entrer dans la zone de la méthode. De nouvelles constantes peuvent également être placées dans la piscine pendant l'exécution. Cette fonctionnalité est plus couramment utilisée par les développeurs. La méthode inter () de la classe de chaîne.

La méthode inter () de la chaîne découvrira s'il y a une chaîne d'égale égale dans le pool constant. S'il y en a, il renverra une référence à la chaîne. S'il n'y a pas, il ajoutera sa propre chaîne au pool constant.

 public static void main (String [] args) {String S1 = new String ("Computer"); String S2 = S1.intern (); String S3 = "Computer"; System.out.println ("S1 == S2?" + (S1 == S2)); System.out.println ("S3 == S2?" + (S3 == S2));}

 S1 == S2? falses3 == S2? vrai

Résumer

Ce qui précède consiste à explorer les piscines constantes de Java en profondeur. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler.