使用StringBuilder替代"+"运算符拼接字符串更优吗？后者是否有弊端或取决于使用场景？

Great question! This is a common pitfall for Java developers (I’m assuming we’re talking Java here, since StringBuilder is a core Java class). The short answer: it depends entirely on your use case—neither is universally better, and each has its own sweet spot.

When the "+" Operator is Totally Fine #

First off, don’t panic every time you use + for string concatenation. Modern Java compilers are smart—they automatically optimize simple, single-line concatenations to use StringBuilder under the hood.

For example, if you write:

String fullName = firstName + " " + lastName;

The compiler will translate this roughly to:

String fullName = new StringBuilder()
    .append(firstName)
    .append(" ")
    .append(lastName)
    .toString();

In cases like this, using + is just as performant as StringBuilder, and your code stays cleaner and more readable. No need to overcomplicate things here.

When "+" Becomes a Problem #

The trouble starts when you use + in loops or repeated, dynamic concatenation scenarios. Since Java Strings are immutable (they can’t be changed once created), every time you do result += "something", you’re actually creating a brand new String object.

Take this example:

String result = "";
for (int i = 0; i < 1000; i++) {
    result += "item " + i + ", ";
}

Each iteration creates a new String and discards the old one. For 1000 iterations, that’s 1000 unnecessary objects cluttering up memory, forcing the garbage collector to work overtime. This gets exponentially worse as the number of iterations grows.

StringBuilder to the Rescue #

This is exactly where StringBuilder shines. It’s designed for mutable string operations—you can append, insert, or modify the string buffer without creating new objects every time.

Rewriting the loop above with StringBuilder:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("item ").append(i).append(", ");
}
String result = sb.toString();

Here, we only create one StringBuilder instance, and all operations modify it in place. The performance difference is night and day for large-scale concatenation.

A quick side note: if you’re working in a multi-threaded environment, use StringBuffer instead—it’s thread-safe (with synchronized methods) but slightly less performant than StringBuilder (which isn’t thread-safe). For most single-threaded use cases, StringBuilder is the way to go.

Final Rule of Thumb #

• Use + for simple, one-off concatenations (e.g., combining a few fixed/variable strings in a single line). Readability beats micro-optimization here.
• Use StringBuilder (or StringBuffer) for loop-based concatenation, dynamic string building, or when you’re modifying the string multiple times. Performance matters here, and you’ll avoid unnecessary object churn.

内容的提问来源于stack exchange，提问作者adsip