Item 63: Cuidado com o desempenho da concatenação de string

1. Concatenação de Strings com o operador (+):
Usar o operador + para concatenar strings é conveniente para poucas concatenações, mas apresenta problemas de desempenho para operações em grande escala, devido à imutabilidade das strings.
Cada vez que uma nova string é criada, o conteúdo de todas as strings anteriores é copiado, resultando em um tempo quadrático para grandes concatenações.

Exemplo incorreto (concatenação repetida com +):

public String criaFatura(List<Item> itens) {
    String fatura = "";
    for (Item item : itens) {
        fatura += item.toString();  // ineficiente para grandes listas
    }
    return fatura;
}

2. Uso de StringBuilder para melhorar o desempenho:
Em vez de usar +, utilize StringBuilder, que permite a modificação de strings de forma eficiente, alocando memória de maneira dinâmica conforme necessário.
O tempo de concatenação com StringBuilder é linear, o que melhora significativamente o desempenho.

Exemplo correto (uso de StringBuilder):

public String criaFatura(List<Item> itens) {
    StringBuilder fatura = new StringBuilder(itens.size() * 80);  // pré-alocação
    for (Item item : itens) {
        fatura.append(item.toString());
    }
    return fatura.toString();
}

3. Comparação de desempenho:
Mesmo após as melhorias no Java 6 para otimizar o operador +, o uso de StringBuilder continua sendo mais eficiente. Em uma máquina de teste, o uso de StringBuilder foi 6,5 vezes mais rápido do que o operador + em um cenário com 100 itens.

Exemplo de otimização sem pré-alocação:

public String criaFatura(List<Item> itens) {
    StringBuilder fatura = new StringBuilder();  // sem pré-alocação
    for (Item item : itens) {
        fatura.append(item.toString());
    }
    return fatura.toString();
}

4. A moral da história:
Não use + para concatenar muitas strings. O desempenho se torna rapidamente inaceitável conforme o número de concatenações cresce.
Use StringBuilder.append ou alternativas como arrays de caracteres para grandes volumes de concatenações.

5. Outras alternativas:
Além do StringBuilder, é possível considerar o uso de arrays de caracteres para processamento em grande escala ou para combinar strings de maneira mais eficiente, especialmente quando é necessário um controle mais fino sobre o desempenho.

Conclusão:
Utilize StringBuilder para concatenar strings de maneira eficiente.
Evite usar o operador + em loops ou para grandes volumes de strings, pois o desempenho degrada significativamente à medida que o número de concatenações aumenta.

Exemplos do livro: