O uso de “+” na concatenação de strings afeta a eficiência?

Eu trabalhei com String, StringBuilder e StringBuffer em java.
Pensei nessa questão, enquanto pensava do ponto de vista da eficiência.

O uso “+” na concatenação de strings afeta a eficiência?

Sim, mas tão pouco não deveria importar na maioria das vezes.

Usar ‘+’ para constantes de string é o mais eficiente, pois o compilador pode realizar a concatenação.

Se você estiver ingressando em duas Strings, o método concat é o mais eficiente, pois evita o uso de um StringBuilder.

Quase nunca há uma boa razão para usar o StringBuffer, exceto para compatibilidade com versões anteriores. StringBuilder ou StringWriter são uma escolha melhor. No entanto, ainda é usado explicitamente com mais freqüência que o StringBuilder no JDK: P

StringBuffer está morto, long live StringBuffer

Se você estiver concatenando em uma única instrução, não importará, pois o compilador / compilador JIT otimizará automaticamente usando um StringBuilder .

Então "a"+b+"c" será otimizado para (new StringBuilder("a").append(b).append("c")).toString()

No entanto, se você estiver concatenando um grande número de String s em um loop, definitivamente use explicitamente um StringBuilder pois ele irá acelerar significativamente o seu programa.

 String a = ""; for( int i = 0; i < 1000000; i++ ) a += i; 

deve ser alterado para

 StringBuilder sb = new StringBuilder(); for( int i = 0; i < 1000000; i++ ) sb.append(i); String a = sb.toString(); 

Um pouco de sim, mas ainda não

Do JLS, 15.18.1.2

Otimização da Concatenação de Cordas

Uma implementação pode optar por executar conversão e concatenação em uma etapa para evitar a criação e, em seguida, descartar um object String intermediário. Para aumentar o desempenho da concatenação de cadeias repetidas, um compilador Java pode usar a class StringBuffer ou uma técnica semelhante para reduzir o número de objects String intermediários que são criados pela avaliação de uma expressão.

Para tipos primitivos, uma implementação também pode otimizar a criação de um object de invólucro, convertendo diretamente de um tipo primitivo para uma cadeia de caracteres.

No seu exemplo:

 " Does +" + " use in String concatenation affect efficiency? " 

nós temos que literalmente Strings, que podem ser substituídos pelo compilador, então isso será mais rápido, do que StringBuffer / append / toString.

Mas eficiente / mais rápido comparado com o que? Execução de código? Código escrito? Leitura de código?

Desde a leitura de um

 "Foo = " + foo; 

é muito fácil, eu recomendaria, contanto que não seja repetido um milhão de vezes, ou um “s + = s2;” repetiu um hundret vezes.

Especialmente,

 System.out.println ("Player " + n + " scolors " + player[n].score); 

é muito melhor legível do que

 System.out.println (new StringBuffer ("Player ").append ((Integer.valueOf (n)).toString ().append (" scolors ").append (... 

Basta evitá-lo em aplicativos que precisam de alto desempenho ou concatenar uma quantidade muito grande de cadeias ou uma grande quantidade recursivamente.

Como as strings são imutáveis, as strings de concatenação causam uma string create. ie .. “A” + “B” + “C” causa a criação de “AB”, depois “ABC”. Se você estiver fazendo várias concatenações, sempre será mais eficiente usar um StringBuilder (não o StringBuffer mais antigo, mas idêntico ao da API, que tem custos de synchronization)

Se você tiver uma concatenação de linha única, o compilador fará isso para você, se possível – ou seja, se você compilar “A” + “B” + “C”, se decompilar, algo como o novo StringBuilder ( “A”). Append (“B”). Append (“C”). ToString (). No entanto, o compilador não pode otimizar várias concats de string em várias linhas – ou seja, se você tiver várias linhas de concatenação, verá algo como o acima em cada linha, incluindo a criação extra de StringBuilder. Melhor fazer isso manualmente.

Você pode verificar isso por si mesmo, reunindo um exemplo simples e descompilando.

Se você estiver usando várias vezes a concatenação com ‘+’, então sim até certo ponto. Porque quando você faz String a + String b, na verdade, internamente cria um object StringBuffer e usa append () de StringBuffer. Assim, toda vez que você fizer um ‘+’, um novo object StringBuffer temporário será criado, inicializado com “a” e, em seguida, anexado com “b”, que será convertido em um object de string.

Portanto, se você precisar de várias concatenações, deverá criar um object StringBuffer (thread-safe) / StringBuilder (não seguro para encadeamentos) e continuar anexando, para evitar a criação de objects StringBuffer novamente e novamente.