Complete Guide to Java StringBuilder with Examples & Best Practices
Introduction
In Java, StringBuilder is a mutable sequence of characters. Unlike String, which is immutable, StringBuilder allows us to modify the content of the string without creating new objects every time we update it. This makes StringBuilder ideal for scenarios where we need to perform many modifications on strings, such as in loops or intensive string manipulations.
✅Why StringBuilder?
- Performance: Repeated string concatenation using
Stringresults in the creation of many temporary objects, leading to memory and CPU overhead. - Mutability:
StringBuilderoffers methods to modify the string directly, improving efficiency. - Use Case: It’s especially useful in scenarios like loops, building large strings, and where thread safety is not a concern (use
StringBufferif thread safety is required).
✅Key Features of StringBuilder
- Mutable sequence of characters.
- Not synchronized (faster than
StringBuffer). - Provides methods like
append(),insert(),delete(),reverse(), andreplace().
✅How to Create a StringBuilder Object
StringBuilder sb1 = new StringBuilder(); // Creates an empty StringBuilder
StringBuilder sb2 = new StringBuilder("Initial text"); // Creates StringBuilder with initial content
✅Commonly Used Methods of StringBuilder
1. append()
Appends the specified string or data to the current sequence.
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");
System.out.println(sb.toString()); // Output: Hello World
2. insert()
Inserts the specified string at the given index.
StringBuilder sb = new StringBuilder("Hello World");
sb.insert(5, ",");
System.out.println(sb.toString()); // Output: Hello, World
3. replace()
Replaces a substring with the specified string.
StringBuilder sb = new StringBuilder("Hello World");
sb.replace(6, 11, "Java");
System.out.println(sb.toString()); // Output: Hello Java
4. delete()
Deletes a substring between the specified indices.
StringBuilder sb = new StringBuilder("Hello Java World");
sb.delete(5, 10);
System.out.println(sb.toString()); // Output: Hello World
5. reverse()
Reverses the characters in the sequence.
StringBuilder sb = new StringBuilder("Hello");
sb.reverse();
System.out.println(sb.toString()); // Output: olleH
6. length() and capacity()
length()returns the number of characters.capacity()returns the allocated storage size.
StringBuilder sb = new StringBuilder();
System.out.println("Length: " + sb.length()); // 0
System.out.println("Capacity: " + sb.capacity()); // Default capacity, usually 16
✅Performance Comparison: String vs StringBuilder
public class PerformanceTest {
public static void main(String[] args) {
long startTime = System.currentTimeMillis();
String str = "";
for (int i = 0; i < 10000; i++) {
str += "a"; // Inefficient due to creating new String objects each time
}
long endTime = System.currentTimeMillis();
System.out.println("String concatenation time: " + (endTime - startTime) + " ms");
startTime = System.currentTimeMillis();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append("a"); // Efficient as it modifies the same object
}
endTime = System.currentTimeMillis();
System.out.println("StringBuilder append time: " + (endTime - startTime) + " ms");
}
}
Typically, StringBuilder performs much faster.
✅When to Use StringBuilder vs StringBuffer vs String
| Feature | String | StringBuilder | StringBuffer |
|---|---|---|---|
| Mutability | Immutable | Mutable | Mutable |
| Thread-Safe | Yes | No | Yes |
| Performance | Low (for frequent modifications) | High | Moderate |
| Use Case | Static text | Single-threaded modifications | Multi-threaded modifications |
🎯Conclusion
StringBuilder is a powerful and efficient class for string manipulation in Java, particularly useful in situations where performance matters. Understanding its key methods helps in writing more efficient and cleaner code compared to using the String class for every small string modification.