What is the problem with string concatenation in Java?

Concatenating strings using the + operator creates a new String object for each intermediate result. This can lead to excessive object creation and increased memory usage, especially in loops.

For example:

// Problem: creating unnecessary String objects
String result = "";
for (int i = 0; i < 100; i++) {
    result = result + i; // Creates a new String object each time
}

To solve this problem, Java provides StringBuilder and StringBuffer. They offer a mutable sequence of characters, allowing efficient modifications without creating new objects on each change.

• StringBuilder (since Java 5) - not synchronized, suitable for single-threaded or externally synchronized contexts. Faster than StringBuffer.
• StringBuffer - synchronized, thread-safe, suitable for multi-threaded environments. Slower than StringBuilder.

Example using StringBuilder:

// Solution using StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
    sb.append(i); // Modify existing object
}
String result = sb.toString(); // Final string creation

Comparison table:

Characteristic	String	StringBuilder	StringBuffer
Mutability	Immutable	Mutable	Mutable
Thread safety	Thread-safe (immutable)	Not thread-safe	Thread-safe
Performance	Low for concatenation	High	Medium (due to synchronization)
Usage	Small strings, constants	Single-threaded operations	Multi-threaded operations

In modern Java versions (Java 9+), the compiler optimizes some concatenation cases with + using invokedynamic and StringConcatFactory, which can partially mitigate the problem. However, for complex or multiple concatenations, using StringBuilder or StringBuffer remains recommended.