Comment Java faire la concaténation de chaîne à l'aide de “+”?

Si vous combinez littérale cordes (littéralement "foo" + "bar"), le compilateur le fait, au moment de la compilation, et non pas au moment de l'exécution.

Si vous avez deux non-chaînes littérales et se joindre à eux avec +, le compilateur (du Soleil, de toute façon) utilisera une StringBuilder sous les couvertures, mais pas forcément de la manière la plus efficace. Ainsi, par exemple, si vous avez ceci:

String repeat(String a, int count) {
    String rv;

    if (count <= 0) {
        return "";
    }

    rv = a;
    while (--count > 0) {
        rv += a;
    }
    return rv;
}

...ce que le Soleil compilateur va produire effectivement, comme le bytecode semble quelque chose comme ceci:

String repeat(String a, int count) {
    String rv;

    if (count <= 0) {
        return "";
    }

    rv = a;
    while (--count > 0) {
        rv = new StringBuilder().append(rv).append(a).toString();
    }
    return rv;
}

(Oui, vraiment — voir le démontage à la fin de cette réponse.) Notez qu'il créé un nouveau StringBuilder à chaque itération, et ensuite converti le résultat de String. Ceci est inefficace (mais il n'a pas d'importance, sauf si vous êtes en train de faire un beaucoup) en raison de toute temporaire, les allocations de mémoire: Il alloue un StringBuilder tampon et, très probablement, de réallouer la mémoire tampon sur le premier append [si rv est à plus de 16 caractères, ce qui est la taille par défaut du tampon] et si ce n'est le premier, puis presque certainement sur la deuxième append, puis alloue un String à la fin — et alors il ne tout nouveau sur la prochaine itération.

Vous pourriez gagner en efficacité, si nécessaire, par la réécriture à utiliser explicitement un StringBuilder:

String repeat(String a, int count) {
    StringBuilder rv;

    if (count <= 0) {
        return "";
    }

    rv = new StringBuilder(a.length() * count);
    while (count-- > 0) {
        rv.append(a);
    }
    return rv.toString();
}

Là, nous avons utilisé un explicite StringBuilder et aussi sa première capacité de la mémoire tampon pour être assez grand pour contenir le résultat. C'est plus efficace de la mémoire, mais bien sûr, légèrement moins clair pour les inexpérimentés code mainteneurs et un peu plus d'une douleur à écrire. Donc si vous trouvez un problème de performance avec un serré chaîne concat boucle, cela pourrait être une façon de l'aborder.

Vous pouvez le voir, cette sous-le-couvre StringBuilder dans l'action avec les éléments suivants de la classe de test:

public class SBTest
{
    public static final void main(String[] params)
    {
        System.out.println(new SBTest().repeat("testing ", 4));
        System.exit(0);
    }

    String repeat(String a, int count) {
        String rv;

        if (count <= 0) {
            return "";
        }

        rv = a;
        while (--count > 0) {
            rv += a;
        }
        return rv;
    }
}

...qui démonte (à l'aide de javap -c SBTest) comme ceci:

Compiled from "SBTest.java"
public class SBTest extends java.lang.Object{
public SBTest();
Code:
0: aload_0
1: invokespecial  #1; //Method java/lang/Object."<init>":()V
4: return
public static final void main(java.lang.String[]);
Code:
0: getstatic   #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3: new   #3; //class SBTest
6: dup
7: invokespecial  #4; //Method "<init>":()V
10: ldc   #5; //String testing
12: iconst_4
13: invokevirtual  #6; //Method repeat:(Ljava/lang/String;I)Ljava/lang/String;
16: invokevirtual  #7; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
19: iconst_0
20: invokestatic   #8; //Method java/lang/System.exit:(I)V
23: return
java.lang.String repeat(java.lang.String, int);
Code:
0: iload_2
1: ifgt  7
4: ldc   #9; //String
6: areturn
7: aload_1
8: astore_3
9: iinc  2, -1
12: iload_2
13: ifle  38
16: new   #10; //class java/lang/StringBuilder
19: dup
20: invokespecial  #11; //Method java/lang/StringBuilder."<init>":()V
23: aload_3
24: invokevirtual  #12; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
27: aload_1
28: invokevirtual  #12; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
31: invokevirtual  #13; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;
34: astore_3
35: goto  9
38: aload_3
39: areturn
}

Note de la façon dont une nouvelle StringBuilder est créé sur chaque itération de la boucle ainsi créée à l'aide de la capacité de la mémoire tampon par défaut.

Tous de cette allocation temporaire des trucs sons laid, mais encore une fois, seulement si vous avez affaire à de substantielles des boucles et/ou des chaînes. Aussi, lorsque la bytecode est exécuté, la JVM peut bien optimiser un peu plus. Sun JVM HotSpot, par exemple, est une très mature JIT optimisation du compilateur. Une fois qu'il est identifié dans la boucle un endroit chaud, il peut bien trouver un moyen de refactoriser le code. Ou pas, bien sûr. 🙂

Ma règle d'or est-je m'inquiéter quand je vois un problème de performance, ou si je sais que je suis en train de faire un beaucoup de concaténation et c'est très probable être un problème de performance et le code ne seront pas affectés de manière significative à partir d'un maintenabilité point de vue si j'utilise un StringBuilder à la place. Les enragés anti-prématuré-optimisation de la ligue serait probablement pas d'accord avec moi sur le deuxième. 🙂

OriginalL'auteur T.J. Crowder

Pour la concaténation d'un nombre fixe de chaînes dans une expression avec +, le compilateur va produire du code à l'aide d'un seul StringBuilder.

E. g. la ligne

String d = a + b + c;

résultats dans le même bytecode comme la ligne

String d = new StringBuilder().append(a).append(b).append(c).toString();

lors de la compilation en utilisant le compilateur javac. (L'Éclipse compilateur produit un peu plus de code optimisé en invoquant new StringBuilder(a), et ainsi de gagner un appel de méthode.)

Comme mentionné dans d'autres réponses, le compilateur va concaténer des chaînes de caractères littérales comme "a" + "b" en une seule chaîne elle-même, la production de pseudo-code binaire qui contient "ab" à la place.

Comme mentionné partout sur le net, vous ne devez pas utiliser + de construire une chaîne de au sein d'une boucle, parce que vous copiez le début de la chaîne à des chaînes de caractères. Dans cette situation, vous devez utiliser un StringBuilder qui vous déclarer en dehors de la boucle.

OriginalL'auteur Christian Semrau

Chaînes sont le plus souvent concaténées
avec l'opérateur+, comme dans
"Hello," + " world" + "!"

Source

OriginalL'auteur inkedmn