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

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 correspond aux deux chaînes et y copie les tableaux de caractères des deux chaînes).

Si vous concattez plusieurs (plus de deux) chaînes dans une ligne, utilisez + ou StringBuilder.append, cela n'a pas d'importance, puisque le compilateur convertit + en StringBuilder.append. C'est une bonne solution pour plusieurs chaînes de caractères, car elle maintient un tableau de caractères qui s'agrandit selon les besoins.

Si vous concattez plusieurs chaînes sur plusieurs lignes, créez un StringBuilder et utilisez la méthode append. À la fin, lorsque vous avez fini d'ajouter des chaînes au StringBuilder, utilisez la méthode .toString() pour créer une chaîne à partir de celui-ci. Pour le concaténage de plusieurs lignes, cette méthode est plus rapide que la deuxième méthode, puisque la deuxième méthode crée un nouveau StringBuilder sur chaque ligne, ajoute les chaînes et les retranscrit ensuite en String, tandis que la troisième méthode n'utilise qu'un seul StringBuilder pour l'ensemble.

Answer 2

Utilisez + opérateur est une bonne pratique, elle est aussi simple et lisible.

Le langage Java fournit un support spécial pour l'opérateur de concaténation des chaînes de caractères ( + ) et pour la conversion d'autres objets en chaînes de caractères. chaînes de caractères. La concaténation de chaînes de caractères est mise en œuvre par la classe StringBuilder(ou StringBuffer) et sa méthode append.

Document officiel : https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

Answer 3

Au niveau du byte code, il n'y a pas de différence et nous ne compromettons pas l'efficacité à ce niveau. Dans le cas de l'exécution du niveau du code à octet, il doit passer par une méthode de surcharge d'opérateur non inline pour + en appelant append. Ensuite, au niveau du langage d'assemblage (Java est écrit en C et le C produit des assemblages similaires à l'assemblage, il y aura un appel de registre supplémentaire pour stocker l'appel de la méthode + dans la pile et il y aura un push supplémentaire. (en réalité, le compilateur croisé peut optimiser l'appel de l'opérateur +, dans ce cas, il n'y a pas de différence avec l'efficacité).

C'est une bonne pratique d'avoir une seule façon d'augmenter la lisibilité :)

Answer 4

Toutes les réponses sont assez bonnes et explicatives. Mais je pense que l'exploration d'autres techniques de concaténation de chaînes de caractères serait également utile, comme Guava Joiner, Streams, String.format, etc.

Pour obtenir des détails complets sur les performances de chaque technique de concaténation. java-string-concatenation-which-way-is-best .

En bref, les performances de concaténation varient en fonction du nombre de chaînes à concaténer. Par exemple - pour concaténer 1-10 chaînes, ces techniques fonctionnent le mieux - StringBuilder, StringBuffer et Plus Operator. Et pour concaténer 100 chaînes de caractères - Guava Joiner, la bibliothèque stringsUtils d'Apache fonctionne également très bien.

Veuillez consulter le blog ci-dessus. Il explique très bien l'efficacité des performances.

Merci.