Comment effacer le tampon de chaîne en Java après une boucle afin que la prochaine itération utilise un tampon de chaîne clair?
Comment effacer le tampon de chaîne en Java après une boucle afin que la prochaine itération utilise un tampon de chaîne clair?
Réponses:
Une option consiste à utiliser la méthode de suppression comme suit:
StringBuffer sb = new StringBuffer();
for (int n = 0; n < 10; n++) {
sb.append("a");
// This will clear the buffer
sb.delete(0, sb.length());
}
Une autre option (nettoyeur de bits) utilise setLength (int len) :
sb.setLength(0);
Voir Javadoc pour plus d'informations:
Le moyen le plus simple de réutiliser le StringBuffer
est d'utiliser la méthodesetLength()
public void setLength(int newLength)
Vous pouvez avoir le cas comme
StringBuffer sb = new StringBuffer("HelloWorld");
// after many iterations and manipulations
sb.setLength(0);
// reuse sb
setLength
place de setlength
.
Vous avez deux options:
Soit utiliser:
sb.setLength(0); // It will just discard the previous data, which will be garbage collected later.
Ou utiliser:
sb.delete(0, sb.length()); // A bit slower as it is used to delete sub sequence.
Évitez de déclarer StringBuffer
ou des StringBuilder
objets dans la boucle sinon cela créera de nouveaux objets à chaque itération. La création d'objets nécessite des ressources système, de l'espace et prend également du temps. Donc pour le long terme, évitez de les déclarer dans une boucle si possible.
buf.delete(0, buf.length());
Je suggère de créer un nouveau StringBuffer
(ou même mieux StringBuilder
) pour chaque itération. La différence de performances est vraiment négligeable, mais votre code sera plus court et plus simple.
public void clear(StringBuilder s) {
s.setLength(0);
}
Usage:
StringBuilder v = new StringBuilder();
clear(v);
pour la lisibilité, je pense que c'est la meilleure solution.
Déjà bonne réponse là-bas. Ajoutez simplement un résultat de référence pour la différence de performance StringBuffer et StringBuild, utilisez une nouvelle instance en boucle ou utilisez setLength (0) en boucle.
Le résumé est: Dans une grande boucle
Benchmark très simple (je viens de changer manuellement le code et de faire un test différent):
public class StringBuilderSpeed {
public static final char ch[] = new char[]{'a','b','c','d','e','f','g','h','i'};
public static void main(String a[]){
int loopTime = 99999999;
long startTime = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for(int i = 0 ; i < loopTime; i++){
for(char c : ch){
sb.append(c);
}
sb.setLength(0);
}
long endTime = System.currentTimeMillis();
System.out.println("Time cost: " + (endTime - startTime));
}
}
Nouvelle instance StringBuilder en boucle: coût en temps: 3693, 3862, 3624, 3742
StringBuilder setLength: Coût du temps: 3465, 3421, 3557, 3408
Nouvelle instance StringBuffer en boucle: coût en temps: 8327, 8324, 8284
StringBuffer setLength Coût du temps: 22878, 23017, 22894
Encore une fois StringBuilder setLength pour m'assurer que mon laboratoire n'a pas de problème à utiliser si longtemps pour StringBuffer setLength :-) Coût du temps: 3448
StringBuffer sb = new SringBuffer();
// do something wiht it
sb = new StringBuffer();
je pense que ce code est plus rapide.