Course: Core Java Training
Topic: Using StringBuilder and StringBuffer
Course Link: Core Java Training Course
Demo Link: Register for a Free Course Demo
Academy Website: JustAcademy
In Java, strings are represented by the String class. A String object is immutable, which means its contents cannot be changed after the object is created. Whenever a program modifies a String, Java creates a new String object for the resulting value.
Repeatedly creating new String objects can cause unnecessary object creation when a program performs many concatenation or modification operations. Java provides the StringBuilder and StringBuffer classes to work with mutable sequences of characters.
Both classes allow developers to append, insert, delete, replace, and reverse characters without creating a new object for every modification.
StringBuilder is a Java class used to create and modify a mutable sequence of characters. It is useful when a program needs to construct or change text repeatedly.
StringBuilder is not synchronized. Its methods do not provide built-in synchronization for safe concurrent modification by multiple threads. This generally makes it a suitable choice for local text manipulation performed by a single thread.
StringBuilder builder = new StringBuilder();
StringBuilder builderWithText = new StringBuilder("Hello");public class StringBuilderExample {
public static void main(String[] args) {
StringBuilder builder = new StringBuilder("Hello");
builder.append(" Java");
System.out.println(builder);
}
}Output:
Hello JavaThe append() method adds text to the existing character sequence. The builder itself is modified, and the returned reference points to the same StringBuilder object.
StringBuffer is another Java class for creating and modifying a mutable sequence of characters. Its methods are synchronized, which helps coordinate access to individual operations when the same StringBuffer instance is shared by multiple threads.
StringBuffer can be useful when multiple threads need to work with the same mutable text object. However, synchronization of individual methods does not automatically make a sequence of several operations atomic. Additional synchronization or another coordination mechanism may be necessary when a complete multi-step operation must be performed as one unit.
StringBuffer buffer = new StringBuffer();
StringBuffer bufferWithText = new StringBuffer("Hello");public class StringBufferExample {
public static void main(String[] args) {
StringBuffer buffer = new StringBuffer("Hello");
buffer.append(" Java");
System.out.println(buffer);
}
}Output:
Hello JavaLike StringBuilder, StringBuffer supports common text modification operations. The main distinction is that StringBuffer synchronizes its methods, while StringBuilder does not.
String text = "Java";
text.concat(" Programming");
System.out.println(text);Output:
JavaThe concat() method returns a new String. Since the returned value is not assigned back to text, the original variable still refers to "Java".
StringBuilder text = new StringBuilder("Java");
text.append(" Programming");
System.out.println(text);Output:
Java ProgrammingThe StringBuilder object's contents are changed by the append operation.
StringBuffer text = new StringBuffer("Java");
text.append(" Programming");
System.out.println(text);Output:
Java ProgrammingStringBuffer also changes its existing character sequence through the append operation.
| Feature | String | StringBuilder | StringBuffer |
|---|---|---|---|
| Mutability | Immutable | Mutable | Mutable |
| Modification | Produces a new String when content changes | Modifies its character sequence | Modifies its character sequence |
| Synchronization | Immutable content; no synchronization needed for its contents | Methods are not synchronized | Methods are synchronized |
| Typical use | Fixed text and string values | Repeated text changes in a single-threaded context | Shared mutable text when synchronized methods are useful |
| Performance considerations | Repeated concatenation can create extra objects | Often preferred for repeated modifications without synchronization | Synchronization may add overhead |
| Common methods | concat(), substring(), equals() | append(), insert(), delete(), reverse() | append(), insert(), delete(), reverse() |
StringBuilder is not guaranteed to outperform StringBuffer in every situation. Actual performance depends on the workload, Java version, and how the code is used. Prefer the class that fits the program's correctness and concurrency requirements.
StringBuilder sb = new StringBuilder();
StringBuffer sf = new StringBuffer();Both objects begin with an empty character sequence and can grow as text is appended. Their default initial capacity is 16 characters.
StringBuilder sb = new StringBuilder("Core Java");
StringBuffer sf = new StringBuffer("Core Java");The supplied text becomes the initial content of the object. The initial capacity is the length of that text plus 16.
StringBuilder sb = new StringBuilder(50);
StringBuffer sf = new StringBuffer(50);The capacity indicates how much character storage is initially available before the internal storage needs to grow. Capacity is not the same as the current length.
The append() method adds a value to the end of the existing character sequence. It supports strings, characters, numbers, booleans, character arrays, and other supported types.
public class AppendExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Java");
sb.append(" Programming");
sb.append(" ");
sb.append(2026);
System.out.println(sb);
}
}Output:
Java Programming 2026StringBuilder sb = new StringBuilder();
sb.append("Age: ");
sb.append(25);
sb.append(", Active: ");
sb.append(true);
System.out.println(sb);Output:
Age: 25, Active: truePractical use: append() is commonly used to construct messages, logs, SQL text, reports, and formatted output. When building SQL queries, use prepared statements and parameters for user-supplied values rather than concatenating untrusted input.
The insert() method inserts a value at a specified position in the existing sequence. Characters at and after that position shift to the right.
builder.insert(index, value);public class InsertExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Hello Java");
sb.insert(6, "Core ");
System.out.println(sb);
}
}Output:
Hello Core JavaThe index must be between zero and the current length, inclusive. An invalid index causes an IndexOutOfBoundsException.
The replace() method replaces characters between a starting index and an ending index. The start index is inclusive, while the end index is exclusive.
public class ReplaceExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("I like Python");
sb.replace(7, 13, "Java");
System.out.println(sb);
}
}Output:
I like JavaHere, the characters at positions 7 through 12 are replaced with "Java". This method replaces a range by index; it is not the same as globally searching for a matching word.
The delete() method removes a range of characters. The deleteCharAt() method removes one character at a specified index.
StringBuilder sb = new StringBuilder("Hello World");
sb.delete(5, 11);
System.out.println(sb);Output:
HelloStringBuilder sb = new StringBuilder("Java!");
sb.deleteCharAt(4);
System.out.println(sb);Output:
JavaCheck the indexes before removing characters. An invalid index or range can cause an IndexOutOfBoundsException.
The reverse() method reverses the order of characters in the current sequence. It is available in both StringBuilder and StringBuffer.
public class ReverseExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Java");
sb.reverse();
System.out.println(sb);
}
}Output:
avaJpublic class PalindromeExample {
public static void main(String[] args) {
String word = "madam";
String reversed = new StringBuilder(word).reverse().toString();
if (word.equals(reversed)) {
System.out.println("Palindrome");
} else {
System.out.println("Not a palindrome");
}
}
}Output:
PalindromeThis example compares the original String with a reversed String. For case-insensitive or punctuation-insensitive palindrome checking, normalize the input before comparing.
| Method | Purpose | Example |
|---|---|---|
| length() | Returns the number of characters currently in the sequence. | sb.length() |
| capacity() | Returns the current storage capacity. | sb.capacity() |
| charAt(index) | Returns the character at a specified index. | sb.charAt(0) |
| setCharAt(index, ch) | Changes the character at a specified index. | sb.setCharAt(0, 'J') |
| substring(start) | Returns a String containing characters from the specified start index to the end. | sb.substring(5) |
| substring(start, end) | Returns a String for the specified range, with the end index excluded. | sb.substring(0, 4) |
| indexOf(text) | Finds the first occurrence of a string. | sb.indexOf("Java") |
| setLength(length) | Changes the sequence length, truncating or adding null characters as needed. | sb.setLength(4) |
| ensureCapacity(minimum) | Requests sufficient capacity for a specified minimum. | sb.ensureCapacity(100) |
| toString() | Creates a String representation of the current sequence. | sb.toString() |
| trimToSize() | Attempts to reduce capacity to match the current length. | sb.trimToSize() |
The length() method returns how many characters are currently stored. The capacity() method returns how many characters can fit in the current internal storage before it needs to grow.
public class CapacityExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Java");
System.out.println("Length: " + sb.length());
System.out.println("Capacity: " + sb.capacity());
}
}Output:
Length: 4
Capacity: 20The initial capacity is 16 plus the length of the supplied string, so the capacity is 20 in this example. If more characters are appended than the available capacity can hold, the internal storage grows automatically.
Methods that expect a String may require conversion from a StringBuilder or StringBuffer. Use toString() to obtain a String containing the current characters.
public class ConversionExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder("Core Java");
String text = sb.toString();
System.out.println(text);
System.out.println(text.getClass().getSimpleName());
}
}Output:
Core Java
StringThe returned String is immutable. Changing the StringBuilder afterward does not change the String value that was already created.
Thread safety matters when multiple threads access the same mutable object. StringBuilder does not synchronize its methods, so concurrent modifications to one shared instance can interfere with one another. StringBuffer synchronizes its individual methods, providing more protection for shared access.
public class SharedBufferExample {
public static void main(String[] args) throws InterruptedException {
StringBuffer buffer = new StringBuffer();
Thread first = new Thread(() -> {
for (int i = 0; i < 100; i++) {
buffer.append("A");
}
});
Thread second = new Thread(() -> {
for (int i = 0; i < 100; i++) {
buffer.append("B");
}
});
first.start();
second.start();
first.join();
second.join();
System.out.println(buffer.length());
}
}Possible output:
200In this example, each append call is synchronized by StringBuffer. The order of A and B characters can vary. The example assumes the threads only append and that no other code modifies the buffer concurrently.
StringBuilder is often a good choice for repeatedly constructing text in a single thread because its methods do not incur StringBuffer's built-in synchronization. StringBuffer may be useful when synchronized methods are appropriate for shared mutable state.
Repeated concatenation of immutable Strings in a loop can create many intermediate objects. A builder often reduces that object creation by modifying one character sequence repeatedly. However, Java compilers and runtimes can optimize some concatenation expressions, so the actual difference depends on the code and runtime.
String result = "";
for (int i = 0; i < 5; i++) {
result += i;
}
System.out.println(result);Output:
01234StringBuilder result = new StringBuilder();
for (int i = 0; i < 5; i++) {
result.append(i);
}
System.out.println(result);Output:
01234For large or repeated text-building operations, StringBuilder is commonly preferred. For very small expressions, ordinary concatenation can be perfectly readable and efficient. Benchmark realistic workloads before making performance claims.
The following program demonstrates how StringBuilder can combine multiple values into a readable report.
public class StudentReport {
public static void main(String[] args) {
StringBuilder report = new StringBuilder();
report.append("Student Report\n");
report.append("------------------\n");
report.append("Name: Riya\n");
report.append("Course: Core Java\n");
report.append("Score: ");
report.append(92);
report.append("%\n");
report.append("Status: Passed");
System.out.println(report.toString());
}
}Output:
Student Report
------------------
Name: Riya
Course: Core Java
Score: 92%
Status: PassedThis approach is useful for generating reports, receipts, summaries, logs, and other text that is built from multiple values.
| Mistake | Explanation | Solution |
|---|---|---|
Using == to compare content |
== compares object references, not character content. |
Use toString().equals(otherString) when comparing with a String. |
| Confusing length and capacity | Length counts current characters; capacity describes available internal storage. | Use length() for content size and capacity() for storage capacity. |
| Using invalid indexes | Some methods throw IndexOutOfBoundsException for invalid positions. | Check the current length and method's index rules. |
| Assuming StringBuilder is thread-safe | Its methods are not synchronized. | Use appropriate synchronization or choose a suitable concurrency design. |
| Assuming StringBuffer makes every workflow atomic | Individual synchronized method calls do not automatically protect a multi-step operation as one unit. | Synchronize the whole operation when required. |
| Forgetting to call toString() | A method may require a String rather than a mutable builder. | Use builder.toString() where a String is required. |
| Overusing mutable builders | Simple concatenation may be clearer for a short expression. | Choose the simplest approach that fits the workload. |
messageBuilder or reportBuffer.toString() when a String result is required.StringBuilder is a mutable sequence of characters that supports repeated text modifications without requiring a new object for every operation.
StringBuffer is a mutable sequence of characters whose methods are synchronized.
StringBuilder methods are not synchronized, while StringBuffer methods are synchronized. This affects their suitability for shared mutable state and may affect performance.
It allows the program to append text to a mutable character sequence rather than repeatedly producing new intermediate String values.
No. Both are mutable, so operations can change their character sequences.
It adds a value to the end of the existing character sequence.
length() returns the number of current characters. capacity() returns the available internal storage capacity before the sequence needs to grow.
It reverses the order of characters in the sequence.
Call its toString() method.
No. It synchronizes individual methods, but the overall design still needs correct coordination for compound operations. Other approaches may be more suitable depending on the application.
Independent StringBuilder instances can be used by separate threads. Concurrently modifying the same instance without coordination is unsafe.
These methods can throw an IndexOutOfBoundsException.
StringBuilder and StringBuffer are essential Java classes for working with mutable text. Both provide methods for appending, inserting, replacing, deleting, and reversing characters. StringBuilder is generally a convenient choice for repeated text construction when a shared synchronized object is not needed, while StringBuffer offers synchronized methods for certain shared-state scenarios.
Understanding their mutability, method behavior, capacity, and thread-safety differences helps developers write clearer and more efficient Java programs. Practice the examples and exercises to become comfortable using both classes in real-world applications.
