¿Cómo se borra el búfer de cadena en Java después de un bucle para que la siguiente iteración utilice un búfer de cadena transparente?

Una opción es utilizar el método de eliminación de la siguiente manera:

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

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

Otra opción (limpiador de bits) usa setLength (int len) :

sb.setLength(0);

Consulte Javadoc para obtener más información:

La forma más sencilla de reutilizar StringBufferes utilizar el métodosetLength()

public void setLength(int newLength)

Puede tener el caso como

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

Tienes dos opciones:

O use:

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

O usar:

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

NOTA

Evite declarar objetos StringBufferu StringBuilderobjetos dentro del ciclo, de lo contrario, creará nuevos objetos con cada iteración. La creación de objetos requiere recursos del sistema, espacio y también lleva tiempo. Por lo tanto, a largo plazo, evite declararlos dentro de un bucle si es posible.

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

Sugiero crear uno nuevo StringBuffer(o incluso mejor StringBuilder) para cada iteración. La diferencia de rendimiento es realmente insignificante, pero su código será más corto y sencillo.

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

Uso:

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

para mayor legibilidad, creo que esta es la mejor solución.

Ya hay una buena respuesta. Simplemente agregue un resultado de referencia para la diferencia de rendimiento de StringBuffer y StringBuild use una nueva instancia en el bucle o use setLength (0) en el bucle.

El resumen es: En un gran bucle

• StringBuilder es mucho más rápido que StringBuffer
• Crear una nueva instancia de StringBuilder en bucle no tiene ninguna diferencia con setLength (0). (setLength (0) tiene una ventaja muy, muy pequeña que la de crear una nueva instancia).
• StringBuffer es más lento que StringBuilder al crear una nueva instancia en bucle
• setLength (0) de StringBuffer es extremadamente más lento que crear una nueva instancia en bucle.

Punto de referencia muy simple (acabo de cambiar manualmente el código y hacer una prueba diferente):

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

}

Nueva instancia de StringBuilder en bucle: costo de tiempo: 3693, 3862, 3624, 3742

Conjunto de StringBuilder Longitud: Coste de tiempo: 3465, 3421, 3557, 3408

Nueva instancia de StringBuffer en bucle: costo de tiempo: 8327, 8324, 8284

StringBuffer setLength Costo de tiempo: 22878, 23017, 22894

Nuevamente StringBuilder setLength para asegurar que mi laboratorio no tenga algún problema para usar tan largo para StringBuffer setLength :-) Costo de tiempo: 3448

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

Creo que este código es más rápido.