String vs StringBuilder vs StringBuffer

JavaEntryjava

The Question

What is the difference between String, StringBuilder, and StringBuffer?

What a Strong Answer Covers

• String immutable thread-safe slow for concatenation
• StringBuilder mutable not thread-safe fastest
• StringBuffer mutable synchronized thread-safe slower
• use StringBuilder single-threaded
• StringBuffer multi-threaded

Senior-Level Answer

String, StringBuilder, and StringBuffer all represent character sequences in Java but differ critically in mutability and thread safety.

String is immutable. Every operation that appears to modify a String (concat, replace, substring) returns a new String object. The original is unchanged. Because Strings are immutable, they are inherently thread-safe, safely cacheable, and interned in the String pool for memory efficiency. The downside is that building a String with repeated concatenation inside a loop creates many intermediate objects, causing GC pressure. The JIT compiler optimizes simple loop-external concatenations using StringBuilder, but explicit StringBuilder is clearer and more efficient for loop-based construction.

StringBuilder is a mutable sequence of characters. Its internal char array can be modified in-place via append(), insert(), delete(), reverse(), and replace(). It is not thread-safe — concurrent access from multiple threads without external synchronization produces unpredictable results. StringBuilder should be the default choice for string construction within a single thread or method.

StringBuffer has the same API as StringBuilder but all its methods are synchronized, making it thread-safe. However, this synchronization has a cost — StringBuffer is measurably slower than StringBuilder in single-threaded contexts. StringBuffer was the original Java 1.0 API; StringBuilder was introduced in Java 5 as a faster single-threaded alternative. In modern Java, StringBuffer is rarely used — if you need thread-safe string construction, higher-level concurrent patterns are usually preferred over StringBuffer.

For string concatenation with the + operator: in Java 9+, the JVM uses invokedynamic and StringConcatFactory which generates efficient bytecode, making simple concatenation outside loops competitive. For building strings in loops, always prefer StringBuilder explicitly.

Key Differences

What Separates a 2/3 from a 3/3

Common Mistakes

• Recommending StringBuffer over StringBuilder for general use — StringBuilder is preferred in single-threaded contexts and covers almost all practical use cases.
• Not knowing that String concatenation with + in Java 9+ uses invokedynamic/StringConcatFactory and is no longer as inefficient as it was in older Java.
• Saying String is 'stored on the stack' — String objects are on the heap; string literals are in the string pool which is also heap-resident since Java 7.

Follow-Up Questions

• Why does repeated String concatenation in a loop with + create performance problems? — Each + creates a new String object copying all previous characters — O(n^2) total work for n concatenations. StringBuilder.append() is O(1) amortized.
• What is the String pool and how does String.intern() relate to it? — The String pool (heap-resident since Java 7) stores unique string literals. intern() manually places a String in the pool or returns the existing canonical copy, enabling reference equality (==) comparison.
• When, if ever, would you use StringBuffer in new code? — Almost never — if you need thread-safe string building you typically have a design problem. Prefer building the string in a single thread with StringBuilder and sharing only the finished immutable String.

Related Questions

• JVM vs JRE vs JDK
• Java Platform Independence
• How JVM Works
• Main Features of Java
• public static void main