Java StringBuilder

Java StringBuilder

Every time you use + to concatenate strings in a loop, Java creates a new String object on each iteration. Ten iterations — ten new objects. A million iterations — a million discarded objects that the garbage collector must clean up. For a few concatenations in simple code, this cost is invisible. In loops, large data processing, or response builders, it becomes a measurable performance problem.

StringBuilder solves this. It maintains a mutable character buffer that grows as you add text. You append, insert, delete, and modify directly inside the same buffer. Only when you call toString() does a single String object get created. One buffer, one String — not one String per concatenation.

What Is StringBuilder?

StringBuilder is a mutable sequence of characters in the java.lang package. Unlike String, which is immutable and creates a new object for every modification, StringBuilder modifies its internal buffer in place.

String concatenation with +:

  step 1: result = "Order"                → creates "Order" object
  step 2: result = result + " ID:"        → creates "Order ID:" object (old discarded)
  step 3: result = result + " ORD-001"    → creates "Order ID: ORD-001" object
  step 4: result = result + " | Status:"  → creates new object
  step 5: result = result + " PLACED"     → creates new object
          ▲
          5 String objects created — 4 discarded immediately

StringBuilder approach:

  sb = new StringBuilder(64)       → one buffer allocated
  sb.append("Order")               → writes into buffer
  sb.append(" ID:")                → extends buffer content
  sb.append(" ORD-001")           → extends buffer content
  sb.append(" | Status:")         → extends buffer content
  sb.append(" PLACED")            → extends buffer content
  result = sb.toString()           → one String object created at the end
  ▲
  1 buffer, 1 final String — 0 intermediate objects discarded

Creating a StringBuilder

Output:
Empty  capacity: 16
Empty  length  : 0
Cap 64 capacity: 64
Content        : Hello
Content length : 5
Content capacity: 21
Auto-grown capacity: 12

Setting an appropriate initial capacity avoids repeated internal array resizing. If you know the output will be around 500 characters, new StringBuilder(512) prevents multiple resize operations during building.

append() — Adding Content

append() is the most used method. It adds content to the end of the buffer. It is heavily overloaded — you can append String, int, double, char, boolean, char[], StringBuilder, and any Object (via its toString()).

Output:
Name: Priya
Age: 24
Salary: Rs.75000.5
Active: true

Address: 14, Koramangala 4th Block, Bengaluru - 560034

CSV: ORD-001,Priya Sharma,1299.50,PLACED,2024-01-15

Language: Java

append() returns this — the same StringBuilder object — which is what makes chaining possible. Each chained call modifies the same buffer and returns it for the next call.

insert() — Adding Content at a Position

insert(offset, value) inserts content at the specified position. All existing characters from that position onward shift right.

Output:
Original  : Hello World
Length    : 11
After insert(5, ',') : Hello, World
After insert(0, '>>> '): >>> Hello, World
After insert at end    : >>> Hello, World <<<

Log with timestamp: [2024-01-15 10:30:00] [INFO] Server started on port 8080

Product: Laptop | Amount: 45999

delete() and deleteCharAt() — Removing Content

delete(start, end) removes characters from start (inclusive) to end (exclusive). deleteCharAt(index) removes a single character at the given index.

Output:
Original: Hello, Beautiful World!
After delete(7,17)  : Hello, World!
After deleteCharAt(5): Hello World!

With quotes   : "Bengaluru"
Without quotes: Bengaluru

Before cleanup: Laptop, Mouse, Keyboard, Monitor, 
After cleanup : Laptop, Mouse, Keyboard, Monitor

The trailing comma removal pattern — build with separators, then delete the last one — is extremely common. An alternative is to check if (i > 0) before appending the separator, but the delete approach often reads more cleanly.

replace() — Replacing a Range

replace(start, end, newString) replaces characters from start (inclusive) to end (exclusive) with newString. The new string can be shorter, longer, or the same length.

Output:
Original: Hello, Java World!
After replace : Hello, Python World!

Masked phone: 987****210

Before: 'Hi!' length=3
After : 'Hello!' length=6

Filled template: Dear Priya, your order ORD-2024-001 of Rs.1299.50 is PLACED.

reverse() — Reversing the Content

reverse() reverses the entire sequence of characters in the buffer. It modifies in place and returns this.

Output:
Original : Hello World
Reversed : dlroW olleH

Palindrome check:
  racecar    → palindrome
  madam      → palindrome
  hello      → not palindrome
  level      → palindrome
  Java       → not palindrome

Original sentence : Java is awesome
Reversed words    : awesome is Java

indexOf(), lastIndexOf(), charAt(), setCharAt()

These methods let you search inside and modify individual characters of the buffer.

Output:
indexOf('Java')      : 0
indexOf('Java', 5)   : 15
lastIndexOf('Java')  : 15
indexOf('Python')    : -1

charAt(0)  : J
charAt(5)  : s

Before setCharAt: Java is great. Java is powerful.
After setCharAt(0,'j'): java is great. java is powerful.

Capitalised: Hello world. This is java. It is fun.

substring() — Extracting Content

substring(start) and substring(start, end) extract a portion of the buffer and return a new String. The buffer itself is unchanged.

Output:
From index 7  : ORD-2024-001 | Customer: Priya | Amount: Rs.1299
Order ID      : ORD-2024-001
Customer name : Priya

Buffer length: 55
Buffer capacity: 71

String vs StringBuilder vs StringBuffer — Comparison Table

Performance Comparison — + vs StringBuilder

Output:
String +      : 2847 ms  (length: 488894)
StringBuilder : 8 ms     (length: 488894)

StringBuilder was ~355x faster

For 100,000 concatenations, StringBuilder is hundreds of times faster. The + operator creates a new String on every iteration — each one copies all previous content into a new array. StringBuilder writes into the same growing buffer — only the new content is copied each time.

Basic Example

Output

Items : Apple, Banana, Cherry
Length: 21

How it works:

1. ›sb starts as an empty, mutable buffer.
2. ›The loop calls append() for each item, writing directly into the same buffer instead of creating a new object every time.
3. ›A comma and space are appended between items, but not after the last one.
4. ›sb.toString() is called once, at the end, to produce the final String — this is far more efficient than using + inside the loop.

Best Practices

Use StringBuilder inside any loop that builds a string. Even a loop with just ten iterations benefits from StringBuilder. The performance gap grows with iteration count — for loops processing thousands or millions of records, StringBuilder is not optional.

Set initial capacity when the final size is roughly predictable. new StringBuilder(capacity) pre-allocates the internal array. Without it, StringBuilder starts at 16 characters and doubles each time it runs out. For emails, reports, or SQL statements of predictable size, pre-allocating avoids multiple internal copy operations.

Use toString() only once — at the very end. Every toString() call creates a new String object from the buffer's content. Calling it inside a loop or multiple times within one build operation wastes memory. Build everything first, then convert once.

Chain append() calls for readability when building in sequence. sb.append("Name: ").append(name).append(" | Age: ").append(age) is more readable than multiple separate statements and produces identical bytecode.

Common Mistakes

Mistake 1 — Converting to String Inside a Loop

Mistake 2 — Using StringBuilder When String Is Enough

+ for two or three fixed concatenations outside a loop is perfectly fine. The compiler optimises such expressions into StringBuilder internally anyway. Reserve explicit StringBuilder for loops, dynamic building, and frequent modifications.

Mistake 3 — Confusing StringBuilder.replace() With String.replace()

String.replace() replaces all occurrences of a literal substring. StringBuilder.replace() replaces a range specified by start and end indices. They are fundamentally different operations with the same method name.

Mistake 4 — Not Removing the Trailing Separator

Interview Questions

Q1. What is StringBuilder and why is it preferred over String concatenation in loops?

StringBuilder is a mutable character buffer in java.lang that supports efficient in-place string building. When you concatenate strings using + in a loop, each iteration creates a new String object — all previous content is copied into each new object. For N iterations, this creates O(N²) total character copies. StringBuilder maintains a single buffer throughout, appending to it directly. Only the final toString() call creates a String. For N appends, only O(N) total characters are copied.

Q2. What is the difference between StringBuilder and StringBuffer?

Both are mutable and have the same methods. The key difference is thread safety: StringBuffer synchronises every method call, making it safe for use across multiple threads but slower. StringBuilder is not synchronised, making it faster for single-threaded use. In modern Java, most string building happens in a single thread — local variables in a method are not shared between threads. For these cases, StringBuilder is the recommended choice. Use StringBuffer only when the same mutable string object is genuinely shared and modified by multiple threads simultaneously.

Q3. What does the capacity() method return in StringBuilder?

capacity() returns the current size of the internal character array allocated for the buffer. It is always greater than or equal to length(). When content is appended that would exceed the current capacity, StringBuilder allocates a new larger array (typically oldCapacity * 2 + 2) and copies the existing content. length() returns the actual number of characters currently in the buffer — always less than or equal to capacity(). Setting an appropriate initial capacity with new StringBuilder(n) avoids these resize operations.

Q4. Does StringBuilder have a replace() method and how does it differ from String.replace()?

Yes. StringBuilder.replace(start, end, newStr) replaces the characters in the buffer from start (inclusive) to end (exclusive) with newStr. It replaces a positional range — not all occurrences of a substring. String.replace(target, replacement) replaces all occurrences of a literal substring throughout the entire string. They address completely different needs: StringBuilder.replace() for positional modification, String.replace() for global substitution.

Q5. Is StringBuilder thread-safe? What should you use when building strings across multiple threads?

StringBuilder is not thread-safe. If two threads simultaneously call append() or other modifying methods on the same StringBuilder, the result is unpredictable — characters can interleave or the internal state can become corrupt. For multi-threaded scenarios, use StringBuffer which synchronises all methods. Alternatively — and often better — keep string building within a single thread and use a thread pool where each thread has its own StringBuilder.

Q6. At what point should you prefer String over StringBuilder?

Use String for fixed values, constants, method parameters that are not built in loops, and all comparisons. String's immutability makes it safe to pass between methods and threads without defensive copying. Use StringBuilder when you are building a string iteratively — especially in loops — or when you need to insert, delete, replace, or reverse parts of a string in place. The compiler automatically converts simple multi-part + expressions outside loops into StringBuilder internally, so explicit StringBuilder is mainly needed for loops and dynamic construction.

FAQs

Can StringBuilder hold null values?

sb.append(null) appends the string "null" to the buffer — it does not throw an exception. insert(offset, null) also appends "null". This is different from String.valueOf(null) which also returns "null". If you do not want nulls appended, add an explicit null check before calling append().

What happens when StringBuilder runs out of capacity?

When a append() or insert() call would exceed the current capacity, StringBuilder automatically allocates a new internal array of size max(newLength, oldCapacity * 2 + 2), copies all existing content, and continues. This is transparent to the caller. Setting an appropriate initial capacity with new StringBuilder(n) avoids this resizing overhead, especially in performance-critical code.

Is it safe to share a StringBuilder between methods?

Passing a StringBuilder to a method follows the same pass-by-value-of-reference rules as any object. The method receives a reference to the same buffer. Any append(), insert(), delete(), or reverse() call in the method modifies the shared buffer and is visible to the caller. If a method should read the content without modifying it, extract the String first with toString() and pass the String instead.

Can you convert StringBuilder back to a char array?

Yes. sb.toString().toCharArray() converts to a char[]. There is no direct StringBuilder.toCharArray() method — you must go through toString() first. Alternatively, use sb.charAt(i) in a loop to read individual characters from the buffer without creating an intermediate String.

Does the + operator use StringBuilder internally?

Yes, for compile-time expressions. When the Java compiler sees "Hello, " + name + "!" outside a loop, it generates bytecode equivalent to new StringBuilder().append("Hello, ").append(name).append("!").toString(). However, the compiler does NOT perform this optimisation across loop iterations — each iteration of result = result + item still creates a new String. This is why explicit StringBuilder is needed for loops despite the compiler optimisation for simple expressions.

Summary

StringBuilder is the right tool whenever you need to build a String dynamically — especially inside loops. It maintains a single mutable buffer from the first character to the last, creating only one String object when toString() is called at the end. The performance difference against + in loops grows from negligible to hundreds of times faster as iteration counts increase.

The methods you will use most: append() for adding content at the end, insert() for adding at a position, delete() and deleteCharAt() for removal, replace() for range substitution, reverse() for reversing, and indexOf() for searching. All modifying methods return this, enabling clean method chaining.

For interviews, be ready to explain the performance difference with a loop example, describe the difference between StringBuilder and StringBuffer (thread safety), explain what capacity() returns versus length(), and demonstrate the trailing separator removal pattern.

What to Read Next