Quando usar o StringBuilder em Java

É geralmente preferível usar um StringBuilder para concatenação de strings em Java. Esse sempre é o caso?

O que quero dizer é o seguinte: a sobrecarga de criar um object StringBuilder , chamando o método append() e, finalmente, toString() menor do que concatenar strings existentes com o operador + para duas strings ou é aconselhável apenas para mais de ) cordas?

Se existe tal limiar, de que depende (talvez o tamanho da string, mas de que maneira)?

E, finalmente, você trocaria a legibilidade e a concisão da concatenação + para o desempenho do StringBuilder em casos menores, como duas, três ou quatro cadeias?

O uso explícito de StringBuilder para concatenações regulares está sendo mencionado como obsoleto em dicas de otimização Java obsoletas , bem como em mitos urbanos de Java .

Se você usa concatenação de strings em um loop, algo assim,

 String s = ""; for (int i = 0; i < 100; i++) { s += ", " + i; } 

então você deve usar um StringBuilder (não StringBuffer ) ao invés de um String , porque é muito mais rápido e consome menos memory.

Se você tiver uma única declaração,

 String s = "1, " + "2, " + "3, " + "4, " ...; 

então você pode usar String s, porque o compilador usará o StringBuilder automaticamente.

A resposta de Ralph é fabulosa. Eu preferiria usar a class StringBuilder para construir / decorar a String porque o uso dela é mais parecido com o padrão Builder.

 public String decorateTheString(String orgStr){ StringBuilder builder = new StringBuilder(); builder.append(orgStr); builder.deleteCharAt(orgStr.length()-1); builder.insert(0,builder.hashCode()); return builder.toString(); } 

Pode ser usado como um ajudante / construtor para construir o String, não o próprio String.

Como regra geral, sempre use o código mais legível e refatorie somente se o desempenho for um problema. Nesse caso específico, os JDKs mais recentes realmente otimizarão o código para a versão do StringBuilder em qualquer caso.

Você normalmente só precisa fazer isso manualmente se estiver fazendo uma concatenação de strings em um loop ou em algum código complexo que o compilador não possa otimizar facilmente.

Dê uma olhada em: http://www.javaspecialists.eu/archive/Issue068.html e http://www.javaspecialists.eu/archive/Issue105.html

Faça os mesmos testes em seu ambiente e verifique se o JDK mais recente ou sua implementação Java faz algum tipo de operação de sequência melhor com o String ou melhor com o StringBuilder .

Alguns compiladores não podem replace nenhuma concatenação de string por equivalentes StringBuilder. Não deixe de considerar quais compiladores sua fonte usará antes de confiar nas otimizações de tempo de compilation.

O operador + usa internamente public String concat(String str) internamente. Este método copia os caracteres das duas cadeias de caracteres, por isso tem requisitos de memory e complexidade de tempo de execução proporcionais ao comprimento das duas cadeias de caracteres. O StringBuilder funciona de maneira mais eficiente.

No entanto, li aqui que o código de concatenação que usa o operador + é alterado para StringBuilder nos compiladores pós Java 4. Então, isso pode não ser um problema. (Embora eu realmente verifique essa declaração se eu depender dela no meu código!)

Para duas strings, a concat é mais rápida, em outros casos, o StringBuilder é uma opção melhor, veja minha explicação no operador de concatenação (+) vs concat ()

O problema com a concatenação de strings é que isso leva à cópia do object String com todo o custo associado. O StringBuilder não é thread-safe e, portanto, é mais rápido que o StringBuffer, que costumava ser a escolha preferida antes do Java 5. Como regra geral, você não deve fazer a concatenação de String em um loop, que será chamado frequentemente. Eu acho que fazer algumas concatenações aqui e ali não vai te machucar, contanto que você não esteja falando sobre centenas e isso, claro, depende dos seus requisitos de desempenho. Se você está fazendo coisas em tempo real, você deve ter muito cuidado.

O material de certificação da Microsoft aborda essa mesma questão. No mundo .NET, a sobrecarga para o object StringBuilder torna uma concatenação simples de objects 2 String mais eficiente. Eu diria uma resposta semelhante para as strings Java.