Jak wyczyścić bufor ciągów w Javie po pętli, aby w następnej iteracji był używany czysty bufor ciągów?

Jedną z opcji jest użycie metody usuwania w następujący sposób:

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

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

Inna opcja (oczyszczanie bitów) wykorzystuje setLength (int len) :

sb.setLength(0);

Zobacz Javadoc, aby uzyskać więcej informacji:

Najłatwiejszym sposobem ponownego użycia StringBufferjest użycie metodysetLength()

public void setLength(int newLength)

Możesz mieć taki przypadek

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

Masz dwie możliwości:

Albo użyj:

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

Albo użyj:

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

UWAGA

Unikaj deklarowania StringBufferlub StringBuilderobiektów w pętli, w przeciwnym razie utworzy nowe obiekty z każdą iteracją. Tworzenie obiektów wymaga zasobów systemowych, miejsca, a także czasu. Dlatego na dłuższą metę unikaj deklarowania ich w pętli, jeśli to możliwe.

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

Proponuję stworzyć nowy StringBuffer(lub nawet lepszy StringBuilder) dla każdej iteracji. Różnica w wydajności jest naprawdę nieistotna, ale Twój kod będzie krótszy i prostszy.

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

Stosowanie:

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

ze względu na czytelność uważam, że to najlepsze rozwiązanie.

Już dobra odpowiedź. Po prostu dodaj wynik testu porównawczego dla różnicy wydajności StringBuffer i StringBuild, użyj nowej instancji w pętli lub użyj setLength (0) w pętli.

Podsumowanie jest następujące: w dużej pętli

• StringBuilder jest znacznie szybszy niż StringBuffer
• Tworzenie nowej instancji StringBuilder w pętli nie różni się od metody setLength (0). (setLength (0) ma bardzo, bardzo małą przewagę niż tworzenie nowej instancji.)
• StringBuffer jest wolniejszy niż StringBuilder, tworząc nowe wystąpienie w pętli
• setLength (0) StringBuffer jest znacznie wolniejsza niż tworzenie nowej instancji w pętli.

Bardzo prosty test porównawczy (po prostu ręcznie zmieniłem kod i wykonałem inny test):

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

}

Nowe wystąpienie StringBuilder w pętli: Koszt czasu: 3693, 3862, 3624, 3742

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

Nowa instancja StringBuffer w pętli: Koszt czasu: 8327, 8324, 8284

StringBuffer setLength Koszt czasu: 22878, 23017, 22894

Ponownie StringBuilder setLength, aby upewnić się, że mój labtop nie ma problemu z używaniem tak długiego zestawu StringBuffer setLength :-) Koszt czasu: 3448

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

Myślę, że ten kod jest szybszy.