Concaténation de chaînes de caractères en Java - quand utiliser +, StringBuilder et concat

Question

Quand faut-il utiliser + pour la concaténation de chaînes de caractères, quand faut-il préférer StringBuilder et quand convient-il d'utiliser concat.

J'ai entendu dire que StringBuilder est préférable pour la concaténation dans les boucles. Pourquoi en est-il ainsi ?

Merci.

Answer 1

Le compilateur Java moderne convertit vos opérations + en append de StringBuilder. Je veux dire que si vous faites str = str1 + str2 + str3 alors le compilateur générera le code suivant :

StringBuilder sb = new StringBuilder();
str = sb.append(str1).append(str2).append(str3).toString();

Vous pouvez décompiler le code en utilisant DJ ou Cavaj pour le confirmer :) Donc maintenant c'est plus une question de choix que de performance d'utiliser + ou StringBuilder :)

Cependant, étant donné que le compilateur ne le fait pas pour vous (si vous utilisez un SDK Java privé pour le faire, cela peut arriver), StringBuilder est certainement la meilleure solution, car vous évitez beaucoup d'opérations inutiles. String objets.

Answer 2

J'ai tendance à utiliser StringBuilder sur les chemins de code où les performances sont un souci. La concaténation répétée de chaînes de caractères dans une boucle est souvent un bon candidat.

La raison de préférer StringBuilder est que les deux + y concat créent un nouvel objet à chaque fois que vous les appelez (à condition que l'argument de droite ne soit pas vide). Cela peut rapidement donner lieu à un grand nombre d'objets, qui sont presque tous complètement inutiles.

Comme d'autres l'ont souligné, lorsque vous utilisez + plusieurs fois dans la même déclaration, le compilateur peut souvent l'optimiser pour vous. Cependant, d'après mon expérience, cet argument ne s'applique pas lorsque les concaténations sont effectuées dans des instructions distinctes. Il ne s'applique certainement pas aux boucles.

Cela dit, je pense que la priorité absolue devrait être d'écrire un code clair. Il existe d'excellents outils de profilage pour Java (j'utilise YourKit), qui permettent de repérer très facilement les goulets d'étranglement en matière de performances et d'optimiser uniquement les parties qui comptent.

P.S. Je n'ai jamais eu besoin d'utiliser concat .

Answer 3

De Compagnon d'entretien d'embauche Java/J2EE :

String

String est immuable : vous ne pouvez pas modifier un fichier String mais peut le remplacer en créant une nouvelle instance. La création d'une nouvelle instance est assez coûteuse.

//Inefficient version using immutable String
String output = "Some text";
int count = 100;
for (int i = 0; i < count; i++) {
    output += i;
}
return output;

Le code ci-dessus construirait 99 nouveaux String objets, dont 98 seraient jetés immédiatement. La création de nouveaux objets n'est pas efficace.

StringBuffer / StringBuilder

StringBuffer est mutable : utilisez StringBuffer o StringBuilder lorsque vous voulez modifier le contenu. StringBuilder a été ajouté dans Java 5 et il est identique en tous points à StringBuffer sauf qu'elle n'est pas synchronisée, ce qui la rend légèrement plus rapide, mais au prix d'un manque de sécurité.

//More efficient version using mutable StringBuffer
StringBuffer output = new StringBuffer(110);
output.append("Some text");
for (int i = 0; i < count; i++) {
  output.append(i);
}
return output.toString();

Le code ci-dessus crée seulement deux nouveaux objets, le StringBuffer et la finale String qui est retourné. StringBuffer s'étend au fur et à mesure des besoins, ce qui est toutefois coûteux. Il serait donc préférable d'initialiser la fonction StringBuffer avec la bonne taille dès le départ, comme indiqué.

Answer 4

Si tous les éléments concaténés sont des constantes (exemple : "these" + "are" + "constants" ), alors je préfère le +, car le compilateur mettra en ligne la concaténation pour vous. Sinon, l'utilisation de StringBuilder est le moyen le plus efficace.

Si vous utilisez + avec des non-constants, le compilateur utilisera aussi StringBuilder en interne, mais le débogage devient infernal, car le code utilisé n'est plus identique à votre code source.

Answer 5

Ma recommandation serait la suivante :

• + : A utiliser lors de la concaténation de 2 ou 3 chaînes de caractères simplement pour garder votre code bref et lisible.
• StringBuilder : A utiliser lors de l'élaboration d'une sortie de chaîne complexe ou lorsque les performances sont un souci.
• String.format : Vous ne l'avez pas mentionné dans votre question, mais c'est ma méthode préférée pour créer des chaînes de caractères car elle permet de garder le code le plus lisible / concis à mon avis et est particulièrement utile pour les déclarations de journal.
• concat : Je ne pense pas avoir jamais eu l'occasion de l'utiliser.