zone de mémoire java

Grossièrement!

Registre: Existe dans le processeur et ne peut pas être contrôlé
zone de pile: Type de base, la valeur de référence est enregistrée; La gestion de la mémoire se fait en déplaçant le point d'avant en arrière
zone de tas: Objet créé par nouveau
zone statique: Comme le dit le mot, les membres statiques
constant pool: Données confirmées au moment de la compilation et existantes dans .class + autres
Zone non-RAM: disque dur etc.

Zone de chaîne et de tas et pool constant

Sujet principal: Je voudrais vérifier "les données qui sont confirmées au moment de la compilation et qui existent en .class".

String a1 = "aaa";
String a2 = "aaa";
System.out.println(a1 == a2); // true

"aaa" est généré dans la zone de pool contant, et la valeur de référence a1 pointant vers "aaa" est générée dans la zone de pile.
Puisqu'il y a "aaa" dans la zone de pool contant, une valeur de référence a2 pointant vers "aaa" est générée dans la zone de pile.
Puisque a1 et a2 contiennent l'adresse de "aaa", cela devient vrai.

String a3 = new String("aaa");
String a4 = new String("aaa");
System.out.println(a3 == a4); // false

"aaa" est généré dans la zone de tas, et la valeur de référence a3 pointant vers "aaa" est générée dans la zone de pile.
"aaa" est généré dans la zone de tas et la valeur de référence a4 pointant vers "aaa" est générée dans la zone de pile.
a3 et a4 sont faux car ils contiennent des adresses "aaa" différentes.

String a5 = "aaa";
String a6 = new String("aaa");
System.out.println(a5 == a6); // false

"aaa" est généré dans la zone de pool de constantes, et la valeur de référence a5 pointant vers "aaa" est générée dans la zone de pile.
"aaa" est généré dans la zone de tas et la valeur de référence a6 pointant vers "aaa" est générée dans la zone de pile.
a5 et a6 sont faux car ils contiennent des adresses "aaa" différentes.

String a1 = "ab";
String a2 = "a" + "b";
System.out.println(a1 == a2); // true

"ab" est généré dans la zone de pool de constantes, et la valeur de référence a1 pointant vers "ab" est générée dans la zone de pile.
"a" est une constante, "b" est une constante, donc a2 = "ab" au moment de la compilation. Une valeur de référence a2 est générée qui pointe vers "ab" qui existe dans l'interrogation constante.
Puisque a1 et a2 contiennent l'adresse de "ab", cela devient vrai.
Quand je l'ai regardé avec decompile, c'était String a2 =" ab ";.

String a1 = "ab";
String a2 = "a" + new String("b");
System.out.println(a1 == a2); // false

"ab" est généré dans la zone de pool de constantes, et la valeur de référence a1 pointant vers "ab" est générée dans la zone de pile.
La nouvelle chaîne ("") n'est pas finalisée au moment de la compilation. Par conséquent, "b" est généré dans la zone de tas au moment de l'exécution, et en outre la zone de tas "ab" est générée.
Par conséquent, a1 et a2 sont faux car ils contiennent des adresses "ab" différentes.

String a1 = "ab";
String a2 = "b";
String a3 = "a" + a2;
System.out.println(a1 == a3); // false

"ab" est généré dans la zone de pool de constantes, et la valeur de référence a1 pointant vers "ab" est générée dans la zone de pile.
"b" est généré dans la zone de réserve constante, et la valeur de référence a2 pointant vers "ab" est générée dans la zone de pile.
Puisque a2 est une valeur de référence, elle n'est pas fixée au moment de la compilation. Par conséquent, "ab" est généré dans la zone de tas au moment de l'exécution et a3 pointe vers lui.
Par conséquent, a1 est un pool constant et a3 est une zone de tas, il devient donc faux.

String a1 = "ab";
final String a2 = "b";
String a3 = "a" + a2;
System.out.println(a1 == a3); // true

Au final, a2 est considéré comme une constante et a3 est constante + constante = constante.

En le regardant avec décompilateur, il a été compilé comme suit.

String a1 = "ab";
String a2 = "b";
String a3 = "ab";
System.out.println(a1 == a3);

String.intern() Une méthode qui peut étendre le pool de constantes.

Instance de chaîne .intern ()

Si la même valeur existe dans le pool de constantes, sa valeur de référence est renvoyée.
Si la même valeur n'existe pas dans le pool de constantes, générez une valeur dans le pool de constantes et renvoyez sa valeur de référence.

String a1 = "ab";
String a2 = new String("ab");
System.out.println(a1 == a2); // false
a2 = a2.intern();
System.out.println(a1 == a2); // true

"ab" est généré dans la zone de pool de constantes, et la valeur de référence a1 pointant vers "ab" est générée dans la zone de pile.
"ab" est généré dans la zone de tas, et la valeur de référence a2 pointant vers "ab" est générée dans la zone de pile.
False est omis.
Puisque a2.intern () et "ab" existent dans le pool de constantes, renvoyez l'adresse "ab" du pool de constantes à a2.
Les deux a1 et a2 pointent vers "ab" dans le pool continu, c'est donc vrai.

String s = null;
for(int i = 0; i < 100; ++i) {
    s = s + "a";
}

Basé sur la vérification à ce jour Parce que s dans s +" a "; est une variable, un nouvel objet est créé et détruit chaque fois qu'il est exécuté.