java - recibir - Borrar un buffer/generador de cadenas después de un ciclo

recibir datos serial arduino

Question

¿Cómo se borra el búfer de cadenas en Java después de un bucle, por lo que la siguiente iteración utiliza un búfer de cadenas claras?

Answer 1

La forma más fácil de reutilizar StringBuffer es usar el método setLength()

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

Answer 2

Sugiero crear un 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 más simple.

Answer 3

Tienes dos opciones:

Cualquiera de usar:

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 StringBuffer o StringBuilder dentro del bucle, de lo contrario creará nuevos objetos con cada iteración. La creación de objetos requiere recursos del sistema, espacio y también requiere tiempo. Entonces, para el largo plazo, evite declararlos dentro de un bucle si es posible.

Answer 4

Una opción es usar 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 (bit cleaner) usa setLength (int len) :

sb.setLength(0);

Ver Javadoc para más información:

Answer 5

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

El resumen es: En un gran bucle

• StringBuilder es mucho más rápido que StringBuffer
• Crear una nueva instancia de StringBuilder en loop no tiene diferencia con setLength (0). (setLength (0) tiene una ventaja muy muy pequeña que 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 ciclo: Costo de tiempo: 3693, 3862, 3624, 3742

StringBuilder setLength: Costo del tiempo: 3465, 3421, 3557, 3408

Nueva instancia de StringBuffer en ciclo: Costo de tiempo: 8327, 8324, 8284

StringBuffer setLength Costo de tiempo: 22878, 23017, 22894

Nuevamente StringBuilder setLength para asegurarme de que mi labtop no tiene problemas para usar por tanto tiempo para StringBuffer setLength :-) Costo del tiempo: 3448

Answer 6

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

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

Answer 7

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

Answer 8

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

Uso:

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

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