Des doutes sur l'emplacement de stockage des chaînes Java

Question

Il y a une question comme celle-ci :

Combien d'objets sont créés par new String("aaa") ? La réponse est d'en créer une ou deux. La raison est que si la variable aaa existe dans la zone constante, une seule est créée dans le tas ; si la variable aaa n'existe pas dans la zone constante, une seule est créée dans la zone constante ; et un dans le tas.

Mais les résultats de mon test actuel sont incohérents :

String s1 = new String("aaa");
String s2 = "aaa";
System.out.println(s1 == s2); //false

Si new String("aaa") crée des objets à la fois dans le tas et dans la zone constante, alors pourquoi s2 ne réutilise-t-il pas directement la référence au pool constant de s1 ?

Supplément : 
J'ai trouvé que je pensais mal. s1 devrait pointer vers l'élément dans le tas, et s2 pointe vers l'élément dans le pool constant, il est donc correct que les deux ne soient pas égaux. new String("aaa ") crée également des objets dans le pool constant en même temps ?

Ou String s3 = "aa".concat("a"); Ce s3 pointe-t-il vers le tas ou le pool constant ? Peut-il réutiliser les variables dans le pool constant ?

Answer 1

    String s1 = new String("aaa");
    String s2 = "aaa";
    System.out.println(s1 == s2); //false
    System.out.println(s1.intern() == s2); //true

Lorsqu'une instance String appelle la méthode intern(), elle vérifiera s'il existe la même constante de chaîne dans le pool de constantes. Si tel est le cas, sa référence sera renvoyée. Sinon, une chaîne égale à str sera ajoutée à la constante. pool et renvoie sa référence puisque s2 est déjà dans le pool constant, s1.intern() ne le créera pas à nouveau, mais fera directement référence au même "aaa".

Si ce n’est pas assez évident, expérimentons,

public class Cons {
    public static void main(String[] args) throws InterruptedException {
        String s1 = new String("vv");
    }
}

Puis ligne de commande

Notez que le pool constant a VV

Answer 2

Question 1 :

String a = "aaa" créera un objet dans le pool constant si le même objet existe dans le pool constant, alors a pointera directement vers l'objet. Et String a = new String("aaa"), s'il existe dans le pool constant, il ne sera pas créé dans le pool constant, mais uniquement dans le tas.

String a = new String("aaa");
String b = new String("aaa");
System.out.println(a == b);//比较两者堆中的引用返回false
System.out.println(a.intern() == b.intern());//比较两者常量池中的引用，返回true

Question 2 :

Trouvez la réponse dans le code source. String s3 = "aa".concat("a"); est en fait équivalent à String s3 = new String("aaa"), qui créera un objet dans le tas.

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

Answer 3

String ne crée pas une nouvelle instance d'objet String à chaque fois qu'une valeur lui est attribuée ? C'est pourquoi il existe StringBuilder.

Answer 4

Selon la pensée orientée objet, String lui-même sait peut-être mieux s'il faut créer des objets dans le pool constant en même temps. Eh bien, il a une méthode interne().

Answer 5

Les réponses des quelques précédentes sont déjà très bonnes. Permettez-moi d'ajouter que ce que nous disons souvent "mettre la chaîne dans le pool constant" fait référence à mettre la référence de la chaîne dans le pool constant de chaîne (String Pool, qui est essentiellement un pool de constantes de chaîne). table de hachage), la chaîne elle-même est toujours placée sur le tas.

Answer 6

//    new一次就是在堆中创建一个新的对象。不new的话aaa直接在字符串常量中取值;
//    String s2 = "aaa"; 先在内存中寻找aaa，如果有，则将aaa的内存首地址指向了s1，
      如果没有则在堆中中创建一个新的对象。

//    String s1 = new String("aaa");//  
//    不管"aaa"在内存中是否存在，都会在堆中开辟新空间，将字符串"aaa"的内存首地址指向s1。


String a = "aaa";//   aaa在常量池中创建一个对象，将内存首地址指向了a
String b = "aaa";//    直接aaa已经存在的内存首地址指向b。
String c = new String("aaa");// 不管存在与否，在堆中创建1个空间，内存首地址与常量池中的地址完全不同
System.out.println(a==b);// true
System.out.println(a==c);// false