Meilleures pratiques/performances : mélanger StringBuilder.append avec String.concat

Question

J'essaie de comprendre quelle est la meilleure pratique et pourquoi pour concaténer des chaînes de caractères et des variables dans différents cas. Par exemple, si j'ai un code comme celui-ci

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String).append("CCCCCCCCCCC").append(D_String)
    .append("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .append("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");

Est-ce la bonne façon de procéder ? De ce poste j'ai remarqué que le + sur des chaînes de caractères crée une nouvelle instance de StringBuilder, concatène les opérandes et renvoie une conversion de chaîne de caractères, ce qui semble représenter beaucoup plus de travail que de simplement appeler .append() donc si c'est vrai, c'est hors de question. Mais qu'en est-il String.concat() ? Est-il approprié d'utiliser .append() pour chaque concaténation ? Ou seulement pour les variables, et les littéraux peuvent être concaténés avec .concat() ?

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String.concat("CCCCCCCCCCC")).append(D_String
    .concat("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .concat("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));

Quelles sont les règles générales en matière de bonnes pratiques et de performances pour aborder ces situations ? Mon hypothèse est-elle correcte sur + et qu'il ne devrait vraiment pas être utilisé ?

Answer 1

+ opérateur

String s = s1 + s2

Dans les coulisses, cela se traduit par :

String s = new StringBuilder(s1).append(s2).toString();

Imaginez le travail supplémentaire que cela représente si vous avez s1 + s2 ici :

stringBuilder.append(s1 + s2)

au lieu de :

stringBuilder.append(s1).append(s2)

Cordes multiples avec +

Il convient de noter que :

String s = s1 + s2 + s3 + ... +sN

est traduit en :

String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();

concat()

String s = s1.concat(s2);

String crée char[] qui peut s'adapter à la fois s1 et s2 . Copies s1 et s2 dans ce nouveau tableau. En fait, cela demande moins de travail que + opérateur.

StringBuilder.append()

Maintenir une char[] réseau qui s'agrandit en cas de besoin. Pas de supplément char[] est créé si celui qui est interne est suffisamment grand.

stringBuilder.append(s1.concat(s2))

est également peu performant car s1.concat(s2) crée un supplément char[] et copie s1 et s2 pour copier le contenu de ce nouveau tableau dans le tableau interne. StringBuilder char[] .

Ceci étant dit, vous devriez utiliser append() tout le temps et ajouter des chaînes de caractères brutes (votre premier extrait de code est correct).

Answer 2

Le compilateur optimise la concaténation +.

Alors

int a = 1;
String s = "Hello " + a;

est transformé en

new StringBuilder().append("Hello ").append(1).toString();

C'est un excellent sujet ici expliquant pourquoi vous devez utiliser l'opérateur +.

Answer 3

L'optimisation est effectuée automatiquement par le compilateur.

Le compilateur Java2 convertira automatiquement les éléments suivants :

String s = s1 + s2; 

à

String s = (new StringBuffer()).append(s1).append(s2).toString();

Tiré directement du Meilleures pratiques Java sur le site d'Oracles.

Answer 4

Vous devez toujours utiliser append .

concat créer une nouvelle chaîne de manière à ce qu'elle ressemble à ceci + Je pense.

Si vous concat ou utiliser + avec 2 chaînes finales, la JVM peut faire une optimisation, ce qui revient à faire un append dans ce cas.

Answer 5

Je préfère personnellement le Strings.format() une ligne simple et facile à lire formateur de chaînes .

String b = "B value";
String d = "D value";
String fullString = String.format("A %s C %s E F", b, d);
// Output: A B value C D value E F