Wie löscht man den String-Puffer in Java nach einer Schleife, damit die nächste Iteration einen Clear-String-Puffer verwendet?

Eine Möglichkeit besteht darin, die Löschmethode wie folgt zu verwenden:

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

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

Eine andere Option (Bit Cleaner) verwendet setLength (int len) :

sb.setLength(0);

Siehe Javadoc für weitere Informationen:

Der einfachste Weg, das wiederzuverwenden, StringBufferist die Verwendung der MethodesetLength()

public void setLength(int newLength)

Sie können den Fall mögen

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

Sie haben zwei Möglichkeiten:

Verwenden Sie entweder:

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

Oder verwenden Sie:

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

HINWEIS

Vermeiden Sie Deklarationen StringBufferoder StringBuilderObjekte innerhalb der Schleife, da sonst mit jeder Iteration neue Objekte erstellt werden. Das Erstellen von Objekten erfordert Systemressourcen, Speicherplatz und Zeit. Vermeiden Sie es daher auf lange Sicht, sie innerhalb einer Schleife zu deklarieren, wenn dies möglich ist.

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

Ich schlage vor, für jede Iteration eine neue StringBuffer(oder noch bessere StringBuilder) zu erstellen . Der Leistungsunterschied ist wirklich vernachlässigbar, aber Ihr Code wird kürzer und einfacher.

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

Verwendung:

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

Aus Gründen der Lesbarkeit halte ich dies für die beste Lösung.

Schon gute Antwort da. Fügen Sie einfach ein Benchmark-Ergebnis für den Leistungsunterschied zwischen StringBuffer und StringBuild hinzu. Verwenden Sie eine neue Instanz in der Schleife oder setLength (0) in der Schleife.

Die Zusammenfassung lautet: In einer großen Schleife

• StringBuilder ist viel schneller als StringBuffer
• Das Erstellen einer neuen StringBuilder-Instanz in einer Schleife hat keinen Unterschied zu setLength (0). (setLength (0) hat einen sehr sehr kleinen Vorteil als das Erstellen einer neuen Instanz.)
• StringBuffer ist langsamer als StringBuilder, indem eine neue Instanz in einer Schleife erstellt wird
• setLength (0) von StringBuffer ist extrem langsamer als das Erstellen einer neuen Instanz in einer Schleife.

Sehr einfacher Benchmark (ich habe den Code nur manuell geändert und verschiedene Tests durchgeführt):

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

}}

Neue StringBuilder-Instanz in Schleife: Zeitkosten: 3693, 3862, 3624, 3742

StringBuilder setLength: Zeitkosten: 3465, 3421, 3557, 3408

Neue StringBuffer-Instanz in Schleife: Zeitkosten: 8327, 8324, 8284

StringBuffer setLength Zeitkosten: 22878, 23017, 22894

Wieder StringBuilder setLength, um sicherzustellen, dass mein Labtop kein Problem damit hat, so lange für StringBuffer setLength zu verwenden :-) Zeitkosten: 3448

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

Ich denke, dieser Code ist schneller.