web-dev-qa-db-fra.com

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

J'essaie de comprendre quelle est la meilleure pratique et pourquoi de concaténer des littéraux de chaîne et des variables pour 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 façon de le faire? De this post , j’ai remarqué que l’opérateur + sur Strings crée une nouvelle instance de StringBuilder, concatène les opérandes et renvoie une conversion de chaîne, ce qui semble être beaucoup plus laborieux que d’appeler simplement .append(); donc si c'est vrai, alors c'est hors de question. Mais qu'en est-il de String.concat()? Est-il approprié d'utiliser .append() pour chaque concaténation? Ou juste pour les variables, et les littéraux peuvent être ajouté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 des meilleures pratiques et performances pour résoudre ces situations? Mon hypothèse est-elle correcte sur + et ne devrait-elle pas être utilisée?

javastringstringbuilderstring-concatenation
80
Nick Rolando

+ opérateur

String s = s1 + s2

En coulisse, cela se traduit par:

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

Imaginez combien de travail supplémentaire cela ajoute si vous avez s1 + s2 ici:

stringBuilder.append(s1 + s2)

au lieu de:

stringBuilder.append(s1).append(s2)

Plusieurs chaînes avec +

A 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 un tableau char[] qui peut contenir à la fois s1 et s2. Copie le contenu de s1 et s2 dans ce nouveau tableau. Nécessite en réalité moins de travail que l'opérateur +.

StringBuilder.append()

Maintient un tableau interne char[] qui se développe lorsque cela est nécessaire. Aucun char[] supplémentaire n'est créé si le code interne est suffisamment grand.

stringBuilder.append(s1.concat(s2))

fonctionne également mal, car s1.concat(s2) crée un tableau char[] supplémentaire et y copie s1 et s2 uniquement pour copier le contenu du nouveau tableau dans internal StringBuilderchar[].

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

175
Tomasz Nurkiewicz

Le compilateur optimise la + concaténation.

Alors

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

est transformé en

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

Il y a un excellent sujet ici expliquant pourquoi vous devriez utiliser l'opérateur +.

15
user973999

L'optimisation est faite 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 site Web Meilleures pratiques Java sur Oracles.

3
BoldAsLove

Vous devriez toujours utiliser append.

concat créer une nouvelle chaîne de sorte qu'il ressemble assez à + je pense.

Si vous concat ou utilisez + avec 2 String final, la machine virtuelle Java peut procéder à l'optimisation.

2
alain.janinm

Si vous concattez exactement deux chaînes, utilisez String.concat (crée une nouvelle chaîne en créant un nouveau tableau de caractères qui convient à la fois à Strings et y copie les tableaux de caractères des deux chaînes).

Si vous concaténisez plusieurs chaînes (plus de deux) sur une ligne, utilisez + ou StringBuilder.append, cela n'a pas d'importance, car le compilateur convertit + en StringBuilder.append. C'est bon pour plusieurs chaînes car il maintient un tableau de caractères qui grandit selon les besoins.

Si vous concaténisez plusieurs chaînes sur plusieurs lignes, créez un StringBuilder et utilisez la méthode append. En fin de compte, lorsque vous avez terminé d'ajouter des chaînes au StringBuilder, utilisez la méthode .toString () - pour créer une chaîne à partir de celle-ci . un nouveau StringBuilder sur chaque ligne, ajoutez les chaînes, puis reconvertissez-les en chaînes, tandis que la troisième méthode utilise un seul StringBuilder pour l'ensemble.

1
Dakkaron

Utiliser l'opérateur + est la meilleure pratique, il est également simple et lisible.

Le langage Java fournit un support spécial pour la chaîne concaténation (+), et pour la conversion d’autres objets en des cordes. La concaténation de chaînes est implémentée via le fichier StringBuilder (ou StringBuffer) et sa méthode d'ajout.

Document officiel: https://docs.Oracle.com/javase/8/docs/api/Java/lang/String.html

0
foobarfuu

au niveau du code octet, il n'y a pas de différence et nous ne compromettons pas l'efficacité. En cas d'exécution au niveau du code d'octet, il doit passer par la méthode de surcharge non en ligne de l'opérateur pour + en appelant append. puis au niveau du langage Assembly (Java est écrit en C et C produit des assemblages similaires à Assembly, il y aura un appel de registre supplémentaire pour stocker + un appel de méthode dans la pile et il y aura un Push supplémentaire. appel, dans ce cas, ne faisant aucune différence avec l'efficacité.)

Il est recommandé d’avoir un moyen d’augmenter la lisibilité. :)

0
Shevon Silva