Item Beware of string concatenation performance

1. String Concatenation with the operator ( ):
Using the operator to concatenate strings is convenient for a few concatenations, but presents performance issues for large-scale operations due to the immutability of strings.
Each time a new string is created, the contents of all previous strings are copied, resulting in a quadratic time for large concatenations.

Incorrect example (repeated concatenation with ):

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

2. Using StringBuilder to improve performance:
Instead of using , use StringBuilder, which allows you to modify strings efficiently, dynamically allocating memory as needed.
The concatenation time with StringBuilder is linear, which significantly improves performance.

Correct example (use of 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. Performance comparison:
Even after improvements in Java 6 to optimize the operator, using StringBuilder continues to be more efficient. On a test machine, using StringBuilder was 6.5 times faster than the operator in a scenario with 100 items.

Example of optimization without pre-allocation:

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. The moral of the story:
Don't use it to concatenate many strings. Performance quickly becomes unacceptable as the number of concatenations grows.
Use StringBuilder.append or alternatives like character arrays for large volumes of concatenations.

5. Other alternatives:
In addition to StringBuilder, you might consider using character arrays for large-scale processing or to combine strings more efficiently, especially when finer control over performance is needed.

Conclusion:
Use StringBuilder to efficiently concatenate strings.
Avoid using the operator in loops or for large volumes of strings, as performance degrades significantly as the number of concatenations increases.

Examples from the book:

The above is the detailed content of Item Beware of string concatenation performance. For more information, please follow other related articles on the PHP Chinese website!