Java: String concat vs StringBuilder - optimisé, que dois-je faire?

Dans cette réponse, il est dit (implique) que la concaténation de Chaîne est optimisé en StringBuilder opérations de toute façon, quand j'écris mon code, est-il une raison pour écrire StringBuilder code dans la source? Notez que mon cas est différent de l'OP de la question, comme je suis la concaténation/ajoutez des centaines de milliers de lignes.

Pour me faire plus clair: je suis bien conscient des différences de chacun, c'est juste que je ne sais pas si il vaut la peine de l'écrire StringBuilder code parce que c'est moins lisible et lors de sa soi-disant plus lent cousin, la classe String, est converti automatiquement dans le processus de compilation de toute façon.

InformationsquelleAutor Soyuz | 2013-02-18
  1. 111

    Je pense que l'utilisation de StringBuilder vs + dépend vraiment du contexte d'une utilisation en.

    Généralement à l'aide de JDK 1.6 et au-dessus, le compilateur va rejoindre automatiquement les chaînes ensemble à l'aide de StringBuilder.

    String one = "abc";
String two = "xyz";
String three = one + two;

    Cela permettra de compiler String three comme:

    String three = new StringBuilder().append(one).append(two).toString();

    Cela est très utile et nous sauve certains d'exécution. Cependant, ce processus n'est pas toujours optimale. Prenons, par exemple:

    String out = "";
for( int i = 0; i < 10000 ; i++ ) {
    out = out + i;
}
return out;

    Si on compile en bytecode puis décompiler le bytecode généré, nous obtenons quelque chose comme:

    String out = "";
for( int i = 0; i < 10000; i++ ) {
    out = new StringBuilder().append(out).append(i).toString();
}
return out;

    Le compilateur a optimisé la boucle interne, mais n'a certainement pas fait le meilleur possible optimisations. Notre code pour l'améliorer, nous pourrions utiliser:

    StringBuilder out = new StringBuilder();
for( int i = 0 ; i < 10000; i++ ) {
    out.append(i);
}
return out.toString();

    Maintenant, c'est plus optimal que le compilateur a généré code, donc il ya certainement un besoin d'écrire du code à l'aide de la StringBuilder/StringBuffer classes dans les cas où un code efficace est nécessaire. Les compilateurs actuels ne sont pas très bien pour gérer la concaténation de chaînes de caractères dans les boucles, cependant, cela pourrait changer à l'avenir.

    Vous devez regarder attentivement pour voir où vous devez appliquer manuellement StringBuilder et d'essayer de l'utiliser lorsque cela ne va pas réduire la lisibilité de votre code de trop.

    Note: j'ai compilé le code à l'aide de JDK 1.6, et et décompilé le code à l'aide de la javap programme, qui crache du byte-code. Il est assez facile de les interpréter et est souvent une référence utile de regarder en essayant d'optimiser le code. Le compilateur ne vous changer le code de derrière les coulisses de sorte qu'il est toujours intéressant de voir ce que ça donne!

    • Est votre code décompilé (dans la deuxième boucle for) la sortie de la décompilation, ou est-ce votre estimation? Si vous déboguez une pour/boucle while avec un "+" de concaténation de chaîne, vous trouverez que l'objet StringBuilder est pas recréé à chaque boucle, mais en fait le même que celui de les réutiliser. Sinon, si vous êtes à la substitution d'un objet plus lourd (c'est à dire StringBuilder pour la Chaîne), ce que l'optimisation êtes-vous vraiment obtenir?
    • J'aimerais connaître la réponse à @SpencerKormos la question de trop. Le compilateur fait créer un nouveau StringBuilder pour chaque itération de boucle? Pourquoi en serait-elle optimale?
    • En relisant la réponse et le lien dans le cas des OP question, au point que Tom faisait, était que si la méthode concat opération est en cours dans la boucle, alors il n'y a pas d'optimisation par le compilateur sur l'ensemble du bloc de code (qui pourrait inclure la boucle for). Dans ce cas, vous devez déclarer votre StringBuilder avant pour la boucle, et d'utiliser append() à l'intérieur de la boucle, faire de la concat fonctionnement plus efficace (c'est à dire le dernier bloc de code de Tom). L'espoir qui fait sens, et merci pour me ramener à ce!
    • la concaténation de chaînes de caractères à l'aide de + seront tournés vers Stringbuilder de la très biggining de java (web.archive.org/web/20041205170952/http://java.sun.com:80/docs/...)
    InformationsquelleAutor Tom Cammann
  2. 3

    La phrase clé dans votre question est "soi-disant plus lent". Vous devez vous identifier si c'est en effet un goulot d'étranglement, et ensuite voir ce qui est plus rapide.

    Si vous êtes sur le point d'écrire ce code, mais n'ont pas encore écrit, puis écrire ce qui est plus clair pour vous et puis si nécessaire de voir si c'est un goulot d'étranglement.

    Alors qu'il est logique d'utiliser le code que vous considérez plus likey pour être plus rapide, si les deux sont tout aussi lisible, en fait de prendre du temps pour savoir qui est plus rapide lorsque vous n'avez pas un besoin est une perte de temps. La lisibilité de rendement ci-dessus jusqu'à ce que le rendement est inacceptable.

    • En fait, après (seulement) de la réécriture du code dans les deux sens, il y a peu de différence dans la lisibilité puisqu'il s'agit seulement de changer les déclarations de classe et en tournant concat() pour ajouter(). Je crois que je vais rester avec StringBuilder pour assurer le rendement.
    InformationsquelleAutor jmoreno
  3. 2

    Il dépend du cas, mais StringBuilder est pensé pour être un peu plus rapide. Si vous faites de la concaténation de l'intérieur d'une boucle alors je vous suggérons d'utiliser StringBuilder.

    De toute façon, je vous conseille de profil et de tester votre code (si vous faites un tel ajout).

    Attention tout de même: les instances de StringBuilder sont mutables et ne doivent pas être partagées entre les threads (sauf si vous savez vraiment ce que vous faites.) par opposition à la Chaîne, qui sont immuables.

    • Réécriture de la question. Je suis conscient de ce que vous avez dit, je veux juste dire, que dois-je écrire?
    • Il faudrait vraiment une sorte de preuve ou source à sauvegarder "StringBuilder est pensé pour être un peu plus rapide". Je suppose que c'est à cause de l'absence de synchronisation vertical mais encore -- sources, ce serait bien.
    InformationsquelleAutor bssstudio
  4. 0

    Je pourrais vous ai mal compris votre question, mais StringBuilder est plus rapide lors de l'ajout de Chaînes de caractères. Donc, oui, si vous ajoutez "des centaines de milliers de lignes", vous devriez certainement utiliser StringBuilder (ou StringBuffer si vous exécutez une application multithread).

    (Plus approfondie de la réponse dans les commentaires)

    • Apparemment moderne/mature compilateurs Java sont assez intelligents pour convertir la concaténation des opérations en StringBuilder ajouter des opérations, quel est donc le point d'utiliser StringBuilder dans le code lorsque c'est moins lisible, et lorsque Chaîne concats sont convertis en StringBuilder opérations de toute façon?
    • Oh, maintenant je vois votre point de vue, l'officier de pont. Oui, vous avez raison: le compilateur va reconnaître une opportunité pour optimiser votre code et de les remplacer régulièrement Chaîne.concat par StringBuilder la plupart du temps - mais pas toujours. Vous ne pouvez pas compter sur le compilateur. Si le code est complexe, le compilateur peut bien manquer l'occasion de l'optimisation. Si j'étais vous, j'ai choisi de faire mon code un peu moins lisible pour le souci de s'assurer de l'optimisation.
    InformationsquelleAutor cldjr