Diferença entre StringBuilder e StringBuffer

votos
1k

Qual é a principal diferença entre StringBuffere StringBuilder? Existe algum problema de desempenho quando se decidir sobre qualquer um destes?

Publicado 10/12/2008 em 05:34
fonte usuário
Em outras línguas...                            


35 respostas

votos
1k

StringBufferé sincronizado, StringBuildernão é.

Respondeu 10/12/2008 em 05:36
fonte usuário

votos
656

StringBuilderé mais rápido do que StringBufferporque não é synchronized.

Aqui está um teste de benchmark simples:

public class Main {
    public static void main(String[] args) {
        int N = 77777777;
        long t;

        {
            StringBuffer sb = new StringBuffer();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }

        {
            StringBuilder sb = new StringBuilder();
            t = System.currentTimeMillis();
            for (int i = N; i > 0 ; i--) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }
    }
}

Um teste dá os números de 2241 mspara StringBuffervs 753 mspara StringBuilder.

Respondeu 05/05/2010 em 10:15
fonte usuário

votos
225

Basicamente, StringBufferenquanto que os métodos são sincronizadas StringBuildernão são.

As operações são "quase" o mesmo, mas usando sincronizado métodos em um único segmento é um exagero.

Isso é muito bonito sobre isso.

Citação de StringBuilder API :

Esta classe [StringBuilder] fornece uma API compatível com StringBuffer, mas sem garantia de sincronização . Esta classe está concebido para ser utilizado como um substituto de drop-in para StringBuf em lugares onde a memória intermédia de cadeia estava a ser utilizados por um único fio (como é geralmente o caso). Sempre que possível, recomenda-se que esta classe ser utilizado em detrimento de StringBuffer como ele vai ser mais rápido na maioria das implementações.

Por isso, foi feito para substituí-lo.

O mesmo aconteceu com Vectore ArrayList.

Respondeu 10/12/2008 em 05:37
fonte usuário

votos
148

Mas necessário para obter a diferença clara com a ajuda de um exemplo?

StringBuffer ou StringBuilder

Basta usar StringBuildera menos que você realmente está tentando compartilhar um amortecedor entre threads. StringBuilderé os unsynchronized (= menos sobrecarga mais eficientes) irmão menor do original é sincronizado StringBufferclasse.

StringBufferveio primeiro. Sun estava preocupado com exatidão em todas as condições, então eles fizeram-lo sincronizado para torná-lo thread-safe apenas no caso.

StringBuilderveio mais tarde. A maioria dos usos StringBuffereram single-fio e desnecessariamente pagar o custo da sincronização.

Desde StringBuilderé uma substituição drop-in para StringBuffersem a sincronização, não haveria diferenças entre quaisquer exemplos.

Se você está tentando compartilhar entre threads, você pode usar StringBuffer, mas considere se a sincronização de nível superior é necessário, por exemplo, talvez em vez de usar StringBuffer, você deve sincronizar os métodos que usam o StringBuilder.

Respondeu 25/01/2011 em 13:30
fonte usuário

votos
73

Primeiro vamos ver as semelhanças : ambos StringBuilder e StringBuffer são mutáveis. Isso significa que você pode alterar o conteúdo deles, com no mesmo local.

Diferenças : StringBuf é mutável e sincronizado, bem. Onde como StringBuilder é mutável, mas não sincronizada por padrão.

Significado da sincronizado (sincronização) : Quando alguma coisa é sincronizado, em seguida, vários segmentos podem acessar, e modificá-lo sem qualquer efeito problema ou lateral. StringBuffer é sincronizada, para que você possa usá-lo com vários segmentos com qualquer problema.

Qual usar quando? StringBuilder: Quando você precisar de uma corda, que pode ser modificável, e apenas um thread está acessando e modificando-o. StringBuffer: Quando você precisar de uma corda, que pode ser modificável, e vários segmentos estão acessando e modificando-o.

Nota : Não use StringBuffer desnecessariamente, ou seja, não usá-lo, se apenas um thread está modificando e acessá-lo porque ele tem muita bloquear e desbloquear código para sincronização que irá desnecessariamente ocupam tempo de CPU. Não use bloqueios a menos que seja necessário.

Respondeu 11/12/2013 em 08:11
fonte usuário

votos
42

Em linhas simples, StringBuffer não é significativamente mais lento do que StringBuilder , graças a otimizações JVM. E em multithreading, você não pode usar com segurança um StringBuilder.

Aqui está o meu teste:

public static void main(String[] args) {

    String withString ="";
    long t0 = System.currentTimeMillis();
    for (int i = 0 ; i < 100000; i++){
        withString+="some string";
    }
    System.out.println("strings:" + (System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuffer buf = new StringBuffer();
    for (int i = 0 ; i < 100000; i++){
        buf.append("some string");
    }
    System.out.println("Buffers : "+(System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuilder building = new StringBuilder();
    for (int i = 0 ; i < 100000; i++){
        building.append("some string");
    }
    System.out.println("Builder : "+(System.currentTimeMillis() - t0));
}

Resultados:
Cordas: 319740
tampões: 23
Builder: 7!

Então Builders são mais rápidos que Buffers, e muito mais rápido do que cordas concatenação. Agora vamos usar um Executor de vários segmentos:

public class StringsPerf {

    public static void main(String[] args) {

        ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        //With Buffer
        StringBuffer buffer = new StringBuffer();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(buffer));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Buffer : "+ AppendableRunnable.time);

        //With Builder
        AppendableRunnable.time = 0;
        executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        StringBuilder builder = new StringBuilder();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(builder));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Builder: "+ AppendableRunnable.time);

    }

   static void shutdownAndAwaitTermination(ExecutorService pool) {
        pool.shutdown(); // code reduced from Official Javadoc for Executors
        try {
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                pool.shutdownNow();
                if (!pool.awaitTermination(60, TimeUnit.SECONDS))
                    System.err.println("Pool did not terminate");
            }
        } catch (Exception e) {}
    }
}

class AppendableRunnable<T extends Appendable> implements Runnable {

    static long time = 0;
    T appendable;
    public AppendableRunnable(T appendable){
        this.appendable = appendable;
    }

    @Override
    public void run(){
        long t0 = System.currentTimeMillis();
        for (int j = 0 ; j < 10000 ; j++){
            try {
                appendable.append("some string");
            } catch (IOException e) {}
        }
        time+=(System.currentTimeMillis() - t0);
    }
}

Agora StringBuffers levar 157 ms para 100000 Anexa. Não é o mesmo teste, mas em comparação com os anteriores 37 ms, você pode seguramente assumir que StringBuffers Anexa são mais lentos com o uso de multithreading . A razão é que o JIT / hotspot / compilador / algo faz otimizações quando detecta que não há nenhuma necessidade de verificação de bloqueios.

Mas com StringBuilder, você tem java.lang.ArrayIndexOutOfBoundsException , porque um thread concorrente tenta adicionar algo onde não deveria.

Conclusão é que você não tem que perseguir StringBuffers. E onde você tem tópicos, pensar sobre o que eles estão fazendo, antes de tentar ganhar alguns nanossegundos.

Respondeu 15/11/2012 em 17:20
fonte usuário

votos
37

StringBuilder foi introduzido em Java 1.5 para que ele não irá trabalhar com JVMs anteriores.

Desde os Javadocs :

StringBuilder classe fornece uma API compatível com StringBuffer, mas sem garantia de sincronização. Esta classe está concebido para ser utilizado como um substituto de drop-in para StringBuf em lugares onde a memória intermédia de cadeia estava a ser utilizados por um único fio (como é geralmente o caso). Sempre que possível, recomenda-se que esta classe ser utilizado em detrimento de StringBuffer como ele vai ser mais rápido na maioria das implementações.

Respondeu 10/12/2008 em 05:38
fonte usuário

votos
32

Pretty Good Pergunta

Aqui estão as diferenças, tenho notado:

StringBuffer: -

StringBuffer is  synchronized
StringBuffer is  thread-safe
StringBuffer is  slow (try to write a sample program and execute it, it will take more time than StringBuilder)

StringBuilder: -

 StringBuilder is not synchronized 
 StringBuilder is not thread-safe
 StringBuilder performance is better than StringBuffer.

Coisa comum :-

Ambos têm os mesmos métodos com as mesmas assinaturas. Ambos são mutáveis.

Respondeu 11/04/2014 em 21:25
fonte usuário

votos
19

StringBuildere StringBuffersão quase os mesmos. A diferença é que StringBufferé sincronizado e StringBuildernão é. Embora, StringBuilderé mais rápido do que StringBuffer, a diferença de desempenho é muito pouco. StringBuilderé a substituição de um da SUN StringBuffer. Ele só evita a sincronização de todos os métodos públicos. Mais do que isso, a sua funcionalidade é a mesma.

Exemplo de bom uso:

Se o texto vai mudar e é usado por vários segmentos, então é melhor usar StringBuffer. Se o texto vai mudar, mas é usado por uma única linha, então use StringBuilder.

Respondeu 03/12/2010 em 07:38
fonte usuário

votos
19

StringBuilder não é thread-safe. Tampão de corda é. Mais informações aqui .

EDIT: Quanto ao desempenho, depois de hotspot entra em ação, StringBuilder é o vencedor. No entanto, para pequenas iterações, a diferença de desempenho é insignificante.

Respondeu 10/12/2008 em 05:41
fonte usuário

votos
16

StringBuffer

StringBuffer é mutável significa que se pode alterar o valor do objeto. O objeto criado através de StringBuffer é armazenado no heap. StringBuf tem os mesmos métodos como o StringBuilder, mas cada um método em StringBuf é sincronizada que é StringBuf é seguro segmento.

Por isso, não permite que dois threads acessem simultaneamente o mesmo método. Cada método pode ser acessado por um thread por vez.

Mas sendo o segmento de seguros tem desvantagens também, como o desempenho do StringBuffer bate devido ao enfiar propriedade segura. Assim StringBuilder é mais rápido do que o StringBuffer ao chamar os mesmos métodos de cada classe.

valor StringBuffer pode ser alterado, isso significa que ele pode ser atribuído ao novo valor. Hoje em dia é uma pergunta da entrevista mais comuns, as diferenças entre as classes acima. Tampão de cadeia pode ser convertido para a cadeia usando o método toString ().

StringBuffer demo1 = new StringBuffer(“Hello”) ;
// The above object stored in heap and its value can be changed .

demo1=new StringBuffer(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuffer

StringBuilder

StringBuilder é o mesmo que o StringBuffer, que é ele armazena o objeto na pilha e que também pode ser modificado. A principal diferença entre o StringBuffer e StringBuilder é que StringBuilder também não é thread-safe. StringBuilder é rápido, pois não é thread-safe.

StringBuilder demo2= new StringBuilder(“Hello”);
// The above object too is stored in the heap and its value can be modified

demo2=new StringBuilder(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuilder

digite descrição da imagem aqui

Resource: Cordas Vs StringBuffer Vs StringBuilder

Respondeu 20/09/2016 em 17:40
fonte usuário

votos
14

StringBuffer

  • Sincronizado daí multitarefa
  • thread-safe, portanto, retardar
  • -

StringBuilder

  • Introduzido em Java 5.0
  • Assíncrona, portanto, rápido e eficiente
  • Usuário precisa explicitamente para sincronizá-lo, se ele quiser
  • Você pode substituí-lo será StringBuilder, sem qualquer outra alteração
Respondeu 10/12/2008 em 06:00
fonte usuário

votos
12

String é uma imutável.

StringBuffer é um mutável e sincronizado.

StringBuilder também é mutável, mas não sincronizada.

Respondeu 18/03/2013 em 09:12
fonte usuário

votos
11

O javadoc explica a diferença:

Essa classe fornece uma API compatível com StringBuffer, mas sem garantia de sincronização. Esta classe está concebido para ser utilizado como um substituto de drop-in para StringBuf em lugares onde a memória intermédia de cadeia estava a ser utilizados por um único fio (como é geralmente o caso). Sempre que possível, recomenda-se que esta classe ser utilizado em detrimento de StringBuffer como ele vai ser mais rápido na maioria das implementações.

Respondeu 25/01/2011 em 13:21
fonte usuário

votos
9

StringBuilder(introduzido em Java 5) é idêntico a StringBuffer, excepto os seus métodos não são sincronizados. Isso significa que ele tem um desempenho melhor do que o último, mas a desvantagem é que não é thread-safe.

Leia tutorial para mais detalhes.

Respondeu 25/01/2011 em 13:23
fonte usuário

votos
6

StringBuilder é muito mais rápido do que StringBuffer porque é não sincronizado.

Aqui você tem mais uma idéia sobre o custo de sincronizar

Vamos tomar programaticamente olhar o quanto StringBuilder mais rápido do que StringBuffer

public class Test{  
 public static void main(String[] args){  
    long startTime = System.currentTimeMillis();  
    StringBuffer sb = new StringBuffer("Yasir");  
    for (int i=0; i<10000; i++){  
        sb.append("Shabbir");  
    }  
    System.out.println("Time taken by StringBuffer: " + (System.currentTimeMillis() - startTime) + "ms");  
    startTime = System.currentTimeMillis();  
    StringBuilder sb2 = new StringBuilder("Yasir");  
    for (int i=0; i<10000; i++){  
        sb2.append("Shabbir");  
    }  
    System.out.println("Time taken by StringBuilder: " + (System.currentTimeMillis() - startTime) + "ms");  
}  
}  

Saída

Tempo gasto pelo StringBuffer: 16ms

Tempo gasto pelo StringBuilder: 0ms

Respondeu 17/09/2016 em 11:35
fonte usuário

votos
4

Um programa simples que ilustra a diferença entre StringBuffer e StringBuilder:

/**
 * Run this program a couple of times. We see that the StringBuilder does not
 * give us reliable results because its methods are not thread-safe as compared
 * to StringBuffer.
 * 
 * For example, the single append in StringBuffer is thread-safe, i.e.
 * only one thread can call append() at any time and would finish writing
 * back to memory one at a time. In contrast, the append() in the StringBuilder 
 * class can be called concurrently by many threads, so the final size of the 
 * StringBuilder is sometimes less than expected.
 * 
 */
public class StringBufferVSStringBuilder {

    public static void main(String[] args) throws InterruptedException {

        int n = 10; 

        //*************************String Builder Test*******************************//
        StringBuilder sb = new StringBuilder();
        StringBuilderTest[] builderThreads = new StringBuilderTest[n];
        for (int i = 0; i < n; i++) {
            builderThreads[i] = new StringBuilderTest(sb);
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].join();
        }
        System.out.println("StringBuilderTest: Expected result is 1000; got " + sb.length());

        //*************************String Buffer Test*******************************//

        StringBuffer sb2 = new StringBuffer();
        StringBufferTest[] bufferThreads = new StringBufferTest[n];
        for (int i = 0; i < n; i++) {
            bufferThreads[i] = new StringBufferTest(sb2);
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].join();
        }
        System.out.println("StringBufferTest: Expected result is 1000; got " + sb2.length());

    }

}

// Every run would attempt to append 100 "A"s to the StringBuilder.
class StringBuilderTest extends Thread {

    StringBuilder sb;

    public StringBuilderTest (StringBuilder sb) {
        this.sb = sb;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb.append("A");
        }

    }
}


//Every run would attempt to append 100 "A"s to the StringBuffer.
class StringBufferTest extends Thread {

    StringBuffer sb2;

    public StringBufferTest (StringBuffer sb2) {
        this.sb2 = sb2;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb2.append("A");
        }

    }
}
Respondeu 14/03/2014 em 19:40
fonte usuário

votos
3

StringBuffer:

  • Multi fio
  • sincronizada
  • Lento do que StringBuilder

StringBuilder

  • Único-Thread
  • Não-sincronizada
  • Mais rápido do que nunca de Cordas
Respondeu 27/09/2015 em 20:34
fonte usuário

votos
3

StringBuffer

StringBuffer é mutável significa que se pode alterar o valor do objeto. O objeto criado através de StringBuffer é armazenado no heap. StringBuf tem os mesmos métodos como o StringBuilder, mas cada um método em StringBuf é sincronizada que é StringBuf é seguro segmento.

StringBuilder

StringBuilder é o mesmo que o StringBuffer, que é ele armazena o objeto na pilha e que também pode ser modificado. A principal diferença entre o StringBuffer e StringBuilder é que StringBuilder não é thread-safe. StringBuilder é rápido, pois não é thread-safe.

Respondeu 15/06/2015 em 14:11
fonte usuário

votos
3

StringBuffer é mutável. Ele pode mudar em termos de duração e conteúdo. StringBuffers são thread-safe, o que significa que eles têm sincronizado métodos para controlar o acesso de modo que apenas um thread pode acessar o código sincronizado de um objeto StringBuffer de cada vez. Assim, os objetos StringBuffer são geralmente seguros para usar em um ambiente multi-threaded, onde vários segmentos podem estar tentando acessar o mesmo objeto StringBuffer ao mesmo tempo.

StringBuilder classe A StringBuilder é muito semelhante ao StringBuffer, exceto que seu acesso não é sincronizado de modo que não é thread-safe. Por não ser sincronizado, o desempenho de StringBuilder pode ser melhor do que StringBuffer. Assim, se você estiver trabalhando em um ambiente single-threaded, usando StringBuilder em vez de StringBuffer pode resultar em aumento de desempenho. Isto também se aplica a outras situações, tais como uma variável local StringBuilder (isto é, uma variável dentro de um método), em que somente um segmento será aceder a um objecto StringBuilder.

Respondeu 05/09/2014 em 11:02
fonte usuário

votos
3

Melhor StringBuilder uso, uma vez que não está sincronizada e portanto melhor desempenho. StringBuilder é uma substituição drop-in do StringBuffer mais velho.

Respondeu 25/01/2011 em 13:21
fonte usuário

votos
3

StringBufferé sincronizado, mas StringBuildernão é. Como resultado, StringBuilderé mais rápido do que StringBuffer.

Respondeu 23/12/2009 em 09:42
fonte usuário

votos
2

String-Builder :

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

String-tampão

StringBuffer sBuffer = new StringBuffer("test");
sBuffer.append(" String Buffer");
System.out.println(sBuffer);  

Recomenda-se usar StringBuilder, sempre que possível, porque é mais rápido do que StringBuffer. No entanto, se a segurança do segmento é necessário, a melhor opção é objetos StringBuffer.

Respondeu 01/02/2017 em 08:44
fonte usuário

votos
2

Verificar as partes internas do método de acréscimo de sincronizado StringBuffere método não sincronizada de acréscimo de StringBuilder.

StringBuffer :

public StringBuffer(String str) {
    super(str.length() + 16);
    append(str);
}

public synchronized StringBuffer append(Object obj) {
    super.append(String.valueOf(obj));
    return this;
}

public synchronized StringBuffer append(String str) {
    super.append(str);
    return this;
}

StringBuilder :

public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
}

public StringBuilder append(Object obj) {
    return append(String.valueOf(obj));
}

public StringBuilder append(String str) {
    super.append(str);
    return this;
}

Desde anexar for synchronized, StringBuffertem sobrecarga de desempenho em comparação com StrinbBuilderno cenário multi-threading. Contanto que você não está compartilhando tampão entre vários tópicos, uso StringBuilder, que é rápido devido à ausência de synchronizednos métodos de acréscimo.

Respondeu 09/06/2016 em 07:16
fonte usuário

votos
2

Não há diferenças básicas entre StringBuilder e StringBuffer, existem apenas algumas diferenças entre eles. Em StringBuf os métodos são sincronizados. Isto significa que em um momento apenas um segmento pode operar sobre eles. Se houver mais de um segmento, em seguida, o segundo segmento terá que esperar para a primeira pessoa a terminar ea terceira terá que esperar para o primeiro e segundo para terminar e assim por diante. Isto torna o processo muito lento e, consequentemente, o desempenho no caso de StringBuf é baixo.

Por outro lado é StringBuilder não sincronizada. Isto significa que em um momento vários segmentos pode operar sobre o mesmo objeto StrinBuilder ao mesmo tempo. Isso torna o processo muito rápido e, portanto, o desempenho de StringBuilder é alta.

Respondeu 10/05/2016 em 07:57
fonte usuário

votos
2

Desde StringBufferé sincronizado, ele precisa de algum esforço extra, portanto, com base em perforamance, é um pouco lento do que StringBuilder.

Respondeu 25/07/2013 em 07:39
fonte usuário

votos
2

StringBuffer é usado para armazenar cadeias de caracteres que serão alterados (objetos String não pode ser alterado). Ela se expande automaticamente, conforme necessário. classes relacionadas: String, CharSequence.

StringBuilder foi adicionado em Java 5. Ele é idêntico em todos os aspectos ao StringBuf excepto que não é sincronizado, o que significa que, se vários segmentos estão aceder ao mesmo, ao mesmo tempo, pode haver problemas. Para os programas de segmento único, o caso mais comum, evitando a sobrecarga de sincronização torna o StringBuilder muito ligeiramente mais rápido.

Respondeu 23/04/2009 em 14:44
fonte usuário

votos
1
  • StringBuffer é thread-safe, mas StringBuilder não é thread-safe.
  • StringBuilder é mais rápido que StringBuffer.
  • StringBuf é sincronizado Considerando StringBuilder não está sincronizado.
Respondeu 01/11/2018 em 17:41
fonte usuário

votos
1

A principal diferença é StringBufferestá sincronizado mas StringBuilderé not.If você precisa usar mais de um segmento, então StringBuffer é recommended.But, de acordo com a velocidade de execução StringBuilderé mais rápido que StringBuffer, porque não é sincronizado.

Respondeu 15/11/2013 em 19:05
fonte usuário

votos
1

Este link vai fazer você entender os conceitos de não só StringBuildere StringBuffer, mas também a sua associação ea diferença com Stringclasse. Isso vai fazer você entender quando usar cada classe. http://www.acquireandinspire.org/2013/01/string-string-builder-string-buffer.html

Respondeu 25/07/2013 em 07:38
fonte usuário

votos
1

String é um objecto imutável o que significa que o valor não pode ser alterada, onde como StringBuf é mutável.

O StringBuf é sincronizado, portanto, isento de segmentos em que como StringBuilder não e adequado é apenas para casos único roscados.

Respondeu 17/11/2010 em 12:33
fonte usuário

votos
0

Outros têm justamente salientou as principais diferenças entre os dois. No entanto, em termos de desempenho que eu gostaria de acrescentar que uma otimização de nível JVM "Bloqueio elisão", que poderia fazer a diferença de desempenho no contexto de sincronização a ser quase inexistente. Uma excelente leitura sobre isso é aqui e aqui

Respondeu 19/10/2019 em 12:01
fonte usuário

votos
0

StringBuffer é sincronizado e thread-safe, StringBuilder não é synchrnised e mais rápido.

Respondeu 11/07/2019 em 14:48
fonte usuário

votos
0

Aqui está o resultado de teste de desempenho para Cordas vs StringBuffer vs StringBuilder . Finalmente, StringBuilder ganhou o teste. Veja abaixo para código de teste e resultado.

código :

private static void performanceTestStringVsStringbuffereVsStringBuilder() {
// String vs StringBiffer vs StringBuilder performance Test

int loop = 100000;
long start = 0;

// String
String str = null;
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
  str += i + "test";
}
System.out.println("String - " + (System.currentTimeMillis() - start) + " ms");

// String buffer
StringBuffer sbuffer = new StringBuffer();
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
  sbuffer.append(i).append("test");
}
System.out.println("String Buffer - " + (System.currentTimeMillis() - start) + " ms");

// String builder
start = System.currentTimeMillis();
StringBuilder sbuilder = new StringBuilder();
for (int i = 1; i <= loop; i++) {
  sbuffer.append(i).append("test");
}
System.out.println("String Builder - " + (System.currentTimeMillis() - start) + " ms");

  }

Executa-me em ideone

resultado :

100000 iteração para adicionar um texto único

String - 37489 ms
String Buffer - 5 ms
String Builder - 4 ms

10000 iteração para adicionar um texto único

String - 389 ms
String Buffer - 1 ms
String Builder - 1 ms
Respondeu 24/08/2018 em 07:59
fonte usuário

votos
0

Cada método presente em StringBuffer é sincronizado. portanto, de cada vez apenas um segmento está autorizada a funcionar StringBuf objecto. Ele aumenta o tempo de espera de um fio e cria problemas de desempenho para superar este problema SOL Pessoas intoduced StringBuilder em 1,5 versão.

Respondeu 01/07/2013 em 14:52
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more