Quand utiliser StringBuilder en Java [dupliquer]
Cette question a déjà une réponse ici:
Il est généralement préférable d'utiliser un StringBuilder pour la concaténation de chaînes en Java. Est-ce toujours le cas?
Ce que je veux dire est ceci: Est la surcharge de la création d'un objet StringBuilder, appelant la méthode append() et enfin toString() déjà plus petit que la concaténation de chaînes existantes avec l'opérateur + pour deux chaînes, ou est-ce seulement conseillé pour plus (que deux) chaînes?
S'il existe un tel seuil, de quoi dépend-il (peut-être la longueur de la chaîne, mais de quelle manière)?
Et enfin, échangeriez - vous la lisibilité et la concision de la concaténation + contre la performance du StringBuilder dans des cas plus petits comme deux, trois ou quatre chaînes?
Utilisation explicite de StringBuilder pour régulièrement des concaténations est mentionné comme obsolète à obsolète Java conseils d'optimisation ainsi qu'à Java mythes urbains.
9 answers
Si vous utilisez la concaténation de chaînes dans une boucle, quelque chose comme ceci,
String s = "";
for (int i = 0; i < 100; i++) {
s += ", " + i;
}
, Alors vous devriez utiliser un StringBuilder (pas StringBuffer) au lieu de String, car il est beaucoup plus rapide et consomme moins de mémoire.
Si vous avez une seule instruction,
String s = "1, " + "2, " + "3, " + "4, " ...;
, Alors vous pouvez utiliser Strings, parce que le compilateur utilisera StringBuilder automatiquement.
La réponse de Ralph est fabuleuse. Je préfère utiliser la classe StringBuilder pour construire / décorer la chaîne car son utilisation ressemble plus à un modèle de constructeur.
public String decorateTheString(String orgStr){
StringBuilder builder = new StringBuilder();
builder.append(orgStr);
builder.deleteCharAt(orgStr.length()-1);
builder.insert(0,builder.hashCode());
return builder.toString();
}
Il peut être utilisé comme assistant/constructeur pour construire la chaîne, pas la chaîne elle-même.
En règle générale, utilisez toujours le code le plus lisible et refactorisez uniquement si les performances sont un problème. Dans ce cas spécifique, les JDK les plus récents optimiseront en fait le code dans la version StringBuilder dans tous les cas.
Vous n'avez généralement besoin de le faire manuellement que si vous effectuez une concaténation de chaînes dans une boucle ou dans un code complexe que le compilateur ne peut pas facilement optimiser.
Jeter un oeil à: http://www.javaspecialists.eu/archive/Issue068.html et http://www.javaspecialists.eu/archive/Issue105.html
Effectuez les mêmes tests dans votre environnement et vérifiez si le JDK plus récent ou votre implémentation Java effectue un type d'opération de chaîne mieux avec String ou mieux avec StringBuilder.
Certains compilateurs ne peuvent remplacer aucune concaténation de chaîne par des équivalents StringBuilder. Assurez-vous de considérer quels compilateurs votre source utilisera avant de vous fier aux optimisations de compilation.
L'opérateur + utilise public String concat(String str) en interne. Cette méthode copie les caractères des deux chaînes, elle a donc des besoins en mémoire et une complexité d'exécution proportionnelle à la longueur des deux chaînes. StringBuilder fonctionne plus efficace.
Cependant, j'ai lu ici que le code de concatination utilisant l'opérateur + est changé en StringBuilder sur les compilateurs post Java 4. Donc, cela pourrait ne pas être un problème du tout. (Bien que je vérifierais vraiment cette déclaration si je dépendais de cela dans mon le code!)
Pour les deux chaînes concat est plus rapide, dans d'autres cas StringBuilder est un meilleur choix, voir mon explication dans l'opérateur de concaténation (+) vs concat()
Le problème avec la concaténation de chaîne est qu'elle conduit à la copie de l'objet String avec tout le coût associé. StringBuilder n'est pas threadsafe et est donc plus rapide que StringBuffer, qui était le choix préféré avant Java 5. En règle générale, vous ne devez pas faire de concaténation de chaînes dans une boucle, qui sera appelée souvent. Je suppose que faire quelques concaténations ici et là ne vous fera pas de mal tant que vous ne parlez pas de centaines et cela dépend bien sûr de votre exigences de performance. Si vous faites des choses en temps réel, vous devriez être très prudent.
Le matériel de certification Microsoft répond à cette même question. Dans le monde. NET, la surcharge de l'objet StringBuilder rend une simple concaténation de 2 objets String plus efficace. Je suppose une réponse similaire pour les chaînes Java.