Comment puis-je vider ou vider un StringBuilder? [dupliquer]

il y a essentiellement deux alternatives, en utilisant setLength(0) pour réinitialiser le constructeur de chaîne ou en créer un nouveau à chaque itération. Les deux peuvent avoir des avantages et des inconvénients selon l'utilisation.

si vous connaissez la capacité attendue du StringBuilder à l'avance, en créer une nouvelle à chaque fois devrait être aussi rapide que de définir une nouvelle longueur. Il aidera également le collecteur de déchets, puisque chaque StringBuilder sera de durée relativement courte et le gc est optimisé pour cela.

quand vous ne connaissez pas la capacité, réutiliser le même StringBuilder pourrait être plus rapide. Chaque fois que vous dépassez la capacité lors de l'ajout, un nouveau support de tableau doit être alloué et le contenu précédent doit être copié. En réutilisant le même StringBuilder, il atteindra la capacité nécessaire après quelques itérations et il n'y aura plus de copie par la suite.

delete n'est pas trop compliqué :

myStringBuilder.delete(0, myStringBuilder.length());

vous pouvez aussi faire:

myStringBuilder.setLength(0);

si vous regardez le code source d'un compilateur de caractères ou D'un compilateur de caractères, l'appel setLength() ne fait que Réinitialiser une valeur d'index pour le tableau de caractères. L'utilisation de la méthode setLength sera toujours plus rapide qu'une nouvelle allocation. Ils auraient dû nommer la méthode 'clear' ou 'reset' pour qu'elle soit plus claire.

je voterai pour sb.setLength(0); non seulement parce que c'est un appel de fonction, mais parce qu'il ne copie pas réellement le tableau dans un autre tableau comme sb.delete(0, builder.length()); . Il suffit de remplir les caractères restants pour être 0 et de définir la variable longueur à la nouvelle longueur.

vous pouvez jeter un oeil à leur mise en œuvre pour valider mon point de ici à setLength fonction et delete0 fonction.

StringBuilder s = new StringBuilder();
s.append("a");
s.append("a");
// System.out.print(s); is return "aa"
s.delete(0, s.length());
System.out.print(s.length()); // is return 0

est la voie facile.

vous devez utiliser sb.delete(0, sb.length()) ou sb.setLength(0) et ne pas créer un nouveau StringBuilder().

voir cet article pour la performance: est-il préférable de réutiliser un StringBuilder dans une boucle?

je pense que beaucoup de réponses ici, peut-être manquant d'une méthode qualité inclus dans StringBuilder : .delete(int start, [int] end) . Je sais qu'il s'agit d'une réponse tardive, mais il faut le faire savoir (et l'expliquer un peu plus en détail).

disons que vous avez une table StringBuilder - que vous souhaitez modifier, dynamiquement, tout au long de votre programme (une table sur laquelle je travaille en ce moment le fait), par exemple

StringBuilder table = new StringBuilder();

si vous faites une boucle à travers la méthode et modifier le contenu, utiliser le contenu, puis à jeter le contenu de "nettoyer" le StringBuilder pour la prochaine itération, vous pouvez le supprimer du contenu, par exemple

table.delete(int start, int end). 

début et fin étant les indices des caractères que vous souhaitez supprimer. Vous ne connaissez pas la longueur dans les chars et vous voulez supprimer toute la chose?

table.delete(0, table.length());

maintenant, pour le kicker. StringBuilders , comme mentionné précédemment, prendre beaucoup de frais généraux lorsque modifié fréquemment (et peut par conséquent, utilisez StringBuffer - identique à StringBuilder (avec quelques exceptions) - si votre StringBuilder est utilisé pour l'interfaçage avec l'utilisateur.

si la performance est la principale préoccupation ... l'ironie (IMO) est que les constructions Java pour formater le texte qui va dans le buffer sera beaucoup plus long sur le CPU que l'alloc/realloc/collecte des ordures ... peut-être pas le GC selon le nombre de constructeurs que vous créez et rejetez.

mais en ajoutant simplement une chaîne composée ("Hello World of" + 6E9 + " earthlings.") au tampon est susceptible de faire toute la matière sans conséquence.

et, vraiment, si StringBuilder est impliqué le contenu est complexe et long et plus long qu'un simple String str = "Hi"; (peu importe Java utilise probablement un constructeur en arrière-plan de toute façon).

personnellement, j'essaie de ne pas abuser du GC. Donc, si c'est quelque chose qui va être beaucoup utilisé dans un scénario de feu rapide - comme, disons, écrire des messages de sortie de débogage ... Je viens de supposer déclarer ailleurs et zéro pour les réutiliser.

class MyLogger {
    StringBuilder strBldr = new StringBuilder(256);

    public LogMsg( String stuff ) {

        strBldr.setLength(0);

        // ... prepend status level
        strBldr.append("Info");
        // ... prepend timestamp
        strBldr.append(" " + getTimestamp());
        // ... user msg
        strBldr.append(":" + msg);

        log.write(strBldr.toString());
    }
}