Como você limpa o buffer de cadeias de caracteres em Java após um loop para que a próxima iteração use um buffer de cadeias de caracteres limpas?

Uma opção é usar o método delete da seguinte maneira:

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

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

Outra opção (limpador de bits) usa setLength (int len) :

sb.setLength(0);

Veja Javadoc para mais informações:

A maneira mais fácil de reutilizar o StringBufferé usar o métodosetLength()

public void setLength(int newLength)

Você pode ter o caso como

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

Você tem duas opções:

Ou use:

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

Ou use:

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

NOTA

Evite declarar StringBufferou StringBuilderobjetos dentro do loop, caso contrário, ele criará novos objetos a cada iteração. A criação de objetos requer recursos do sistema, espaço e também leva tempo. Portanto, a longo prazo, evite declará-los em um loop, se possível.

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

Sugiro criar um novo StringBuffer(ou até melhor StringBuilder) para cada iteração. A diferença de desempenho é realmente insignificante, mas seu código será mais curto e mais simples.

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

Uso:

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

para facilitar a leitura, acho que essa é a melhor solução.

Já boa resposta lá. Basta adicionar um resultado de benchmark para que a diferença de desempenho StringBuffer e StringBuild use nova instância no loop ou use setLength (0) no loop.

O resumo é: Em um loop grande

• StringBuilder é muito mais rápido que StringBuffer
• Criar nova instância StringBuilder em loop não tem diferença com setLength (0). (setLength (0) tem uma vantagem muito, muito pequena, do que criar uma nova instância.)
• StringBuffer é mais lento que StringBuilder ao criar nova instância no loop
• setLength (0) de StringBuffer é extremamente mais lento que criar uma nova instância em loop.

Referência muito simples (eu mudei manualmente o código e fiz testes diferentes):

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

}

Nova instância StringBuilder em loop: Custo do tempo: 3693, 3862, 3624, 3742

StringBuilder setLength: Custo do tempo: 3465, 3421, 3557, 3408

Nova instância StringBuffer no loop: Custo do tempo: 8327, 8324, 8284

StringBuffer setLength Custo de tempo: 22878, 23017, 22894

Novamente StringBuilder setLength para garantir que meu labtop não tenha problemas para usar tanto tempo como StringBuffer setLength :-) Custo de tempo: 3448

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

Eu acho que esse código é mais rápido.