Dites-moi votre compréhension et vous êtes invités à faire des suggestions

• a = "a" ; Lors de la compilation, la chaîne "a" est mise dans le pool constant et aucun objet n'est créé sur le tas

• b = "b"; De même

• a = a + b ; crée un objet StringBuilder, append(a), append(b), et enfin renvoie tostring() à a.

• StringBuffer d = new StringBuffer("abc"); Un objet doit être créé ici, et "abc" entre dans le pool de constantes

• d = d.append("567"); StringBuffer utilise un tableau de caractères pour enregistrer la chaîne. L'ajout ajoutera "567" au tableau. Si la capacité du tableau n'est pas suffisante, elle sera étendue. La taille par défaut est 16 + La longueur de "abc" = 19, la longueur de "abc567" est 6, 3 + 3 < 19, cela ne provoquera donc pas d'expansion.

• Un autre point est que StringBuffer et StringBuilder héritent de AbstractStringBuilder, ce qui peut provoquer la création de classes parents.

Voici le code décompilé :

/**
 *
 * 源代码
 *public class TestString {
 *    public static void main(String args[]) {
 *        String a = "a";
 *        String b = "b";
 *        String c = a + b;
 *    }
 *}
 *
 */

Compiled from "TestString.java"
public class TestString {
    public TestString();
Code:
0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

       public static void main(java.lang.String[]);
Code:
       0: ldc           #2                  // String a
       2: astore_1
       3: ldc           #3                  // String b
       5: astore_2
       6: new           #4                  // class java/lang/StringBuilder
       9: dup
       10: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
       13: aload_1
       14: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
17: aload_2
        18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
21: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
24: astore_3
        25: return
}

Laissez-moi d'abord vous dire ma réponse : je pense que c'est 3.

Tout d'abord, clarifions la signification spécifique de 创建对象 D'après ma compréhension, si la chaîne est 字符常量, alors l'objet chaîne est déterminé au moment de la compilation et il est stocké dans le pool constant, donc. Cela ne compte pas comme la création d'un objet chaîne. S'il y a une opération telle que String b = new String("abc"), alors on peut considérer qu'un objet chaîne est créé et associé à la variable b.

Code source :

1: String a,b,c;
2: a = "a";
3: b = "b";
4: a = a+b;
5: StringBuffer d = new StringBuffer("abc");
6: d = d.append("567");

Jetons un coup d'œil au bytecode correspondant :

Code:
  stack=3, locals=5, args_size=1
     0: ldc           #2                  // String a
     2: astore_1
     3: ldc           #3                  // String b
     5: astore_2
     6: new           #4                  // class java/lang/StringBuilder
     9: dup
    10: invokespecial #5                  // Method java/lang/StringBuilder."<init>":()V
    13: aload_1
    14: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
    17: aload_2
    18: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
    21: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
    24: astore_1
    25: new           #8                  // class java/lang/StringBuffer
    28: dup
    29: ldc           #9                  // String abc
    31: invokespecial #10                 // Method java/lang/StringBuffer."<init>":(Ljava/lang/String;)V
    34: astore        4
    36: aload         4
    38: ldc           #11                 // String 567
    40: invokevirtual #12                 // Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
    43: astore        4
    45: return

est traduite dans le code suivant : a = a+b

StringBuilder builder = new StringBuilder();
builder.append(a);
builder.append(b);
a = builder.toString();

est créé ici, puis la méthode new StringBuilder() est appelée. Son code source est le suivant : builder.toString().

@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

crée un objet String, nous avons donc maintenant créé builder.toString().两个对象

crée sans aucun doute l'objet StringBuffer d = new StringBuffer("abc"), nous avons donc StringBuffer Une chose à noter est que 三个对象 n'appelle pas la méthode StringBuffer d du début à la fin, donc non. Une chaîne redondante sera créée.toString

• "a": constante de chaîne, non comptée comme objet créé

• "b": Constante de chaîne, non comptée comme objet créé

• Objet builder : Créé lors de l'exécution de

  .a = a+b

• "ab": Créé par

  .StringBuilder.toString()

• "abc": constante de chaîne, non comptée comme objet créé

• "567" : Constante de chaîne, non comptée comme objet créé

• d : Créé par

  .new StringBuffer("abc")

Merci pour vos réponses. Je comprends probablement Malheureusement, je ne comprends pas le code décompilé maintenant