Come si cancella il buffer di stringa in Java dopo un ciclo in modo che l'iterazione successiva utilizzi un buffer di stringa chiaro?

Un'opzione è utilizzare il metodo di eliminazione come segue:

StringBuffer sb = new StringBuffer();
for (int n = 0; n < 10; n++) {
   sb.append("a");

   // This will clear the buffer
   sb.delete(0, sb.length());
}

Un'altra opzione (bit più pulita) usa setLength (int len) :

sb.setLength(0);

Vedi Javadoc per maggiori informazioni:

Il modo più semplice per riutilizzare StringBufferè utilizzare il metodosetLength()

public void setLength(int newLength)

Potresti avere il caso come

StringBuffer sb = new StringBuffer("HelloWorld");
// after many iterations and manipulations
sb.setLength(0);
// reuse sb

Hai due opzioni:

O usa:

sb.setLength(0);  // It will just discard the previous data, which will be garbage collected later.  

Oppure usa:

sb.delete(0, sb.length());  // A bit slower as it is used to delete sub sequence.  

NOTA

Evita di dichiarare StringBuffero StringBuilderoggetti all'interno del ciclo altrimenti creerà nuovi oggetti ad ogni iterazione. La creazione di oggetti richiede risorse di sistema, spazio e richiede anche tempo. Quindi, a lungo termine, evita di dichiararli all'interno di un ciclo, se possibile.

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

Suggerisco di crearne uno nuovo StringBuffer(o anche migliore StringBuilder) per ogni iterazione. La differenza di prestazioni è davvero trascurabile, ma il codice sarà più breve e più semplice.

public void clear(StringBuilder s) {
    s.setLength(0);
}

Uso:

StringBuilder v = new StringBuilder();
clear(v);

per la leggibilità, penso che questa sia la soluzione migliore.

Già buona risposta lì. Basta aggiungere un risultato di benchmark per StringBuffer e la differenza di prestazioni di StringBuild usa una nuova istanza in loop o usa setLength (0) in loop.

Il riepilogo è: In un ampio ciclo

• StringBuilder è molto più veloce di StringBuffer
• La creazione di una nuova istanza di StringBuilder in loop non ha differenze con setLength (0). (setLength (0) ha un vantaggio molto molto piccolo rispetto alla creazione di una nuova istanza.)
• StringBuffer è più lento di StringBuilder in quanto crea una nuova istanza in loop
• setLength (0) di StringBuffer è estremamente più lento rispetto alla creazione di una nuova istanza in loop.

Benchmark molto semplice (ho appena cambiato manualmente il codice e ho fatto un test diverso):

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));
}

}

Nuova istanza StringBuilder in loop: costo del tempo: 3693, 3862, 3624, 3742

StringBuilder setLength: Time cost: 3465, 3421, 3557, 3408

Nuova istanza StringBuffer in loop: costo del tempo: 8327, 8324, 8284

StringBuffer setLength Costo del tempo: 22878, 23017, 22894

Ancora una volta StringBuilder setLength per garantire che non il mio labtop abbia qualche problema da usare così a lungo per StringBuffer setLength :-) Costo del tempo: 3448

StringBuffer sb = new SringBuffer();
// do something wiht it
sb = new StringBuffer();

penso che questo codice sia più veloce.