Comment effacer le tampon de chaîne en Java après une boucle afin que l'itération suivante utilise un tampon de chaîne vide ?
Quelque chose d'un peu moins nul serait de simplement déclarer le StringBuffer à l'intérieur de la boucle.
Comment effacer le tampon de chaîne en Java après une boucle afin que l'itération suivante utilise un tampon de chaîne vide ?
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 (un peu plus propre) utilise setLength(int len) :
sb.setLength(0);
Voir Javadoc pour plus d'informations :
Quelque chose d'un peu moins nul serait de simplement déclarer le StringBuffer à l'intérieur de la boucle.
Ah, je pense que sb.setLength(0) ; est plus propre et plus efficace que de le déclarer à l'intérieur de la boucle. Votre solution va à l'encontre de l'avantage de performance d'utiliser StringBuffer...
Je pense que l'avantage en termes de performance vient de la mutabilité de la chaîne, et non de la sauvegarde de l'instanciation. Voici un test rapide de 1e8 itérations : inside loop (2.97s) : ideone.com/uyyTL14w boucle extérieure (2.87s) : ideone.com/F9lgsIxh
La manière la plus simple de réutiliser le StringBuffer
est d'utiliser la méthode setLength()
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
Quand je vois le code source de setLength, comment cela fonctionne-t-il ( gist.github.com/ebuildy/e91ac6af2ff8a6b1821d18abf2f8c9e1 ) ici le compte sera toujours supérieur à newLength (0) ?
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
o StringBuilder
dans la boucle, sinon il créera de nouveaux objets à chaque itération. La création d'objets nécessite des ressources système, de l'espace et prend du temps. Donc, à long terme, il faut éviter de les déclarer dans une boucle si possible.
Je suggère de créer un nouveau StringBuffer
(ou encore mieux, StringBuilder
) pour chaque itération. La différence de performance est vraiment négligeable, mais votre code sera plus court et plus simple.
Comme java est maintenant surtout utilisé sur Android, je ne suis pas sûr que l'allocation d'un nouvel objet dans une boucle soit une bonne pratique pour les performances et l'autonomie de la batterie. La complexité du code ajoutée par l'effacement de l'objet StringBuilder
est minime par rapport au gain de performance potentiel.
Si vous avez des preuves d'une telle différence de performance, veuillez les partager. (Je serai également heureux de voir des statistiques sur les endroits où Java est principalement utilisé, et selon quelle définition de "principalement").
Il est bien connu que l'allocation (nouveau mot-clé en Java) est plus coûteuse que le simple changement de certains champs du même objet. Pour la "plupart", que l'on pourrait replacer avec beaucoup de précision, il y a plus de 1,5 milliard d'appareils Android, tous utilisant Java.
Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.
2 votes
Autre question : pourquoi n'utilisez-vous un SB que pour une seule itération de la boucle ? Y a-t-il une autre itération interne ? Le SB n'est pas utile si vous voulez simplement faire A+B+C+D (le compilateur Java utilisera un SB en interne). Il est utile si vous voulez ajouter conditionnellement des parties de chaînes de caractères, mais sinon... utilisez simplement "+".