Introduction to Java

StringBuilder Class in Java

Last Updated : 26 Jul, 2025

In Java, the StringBuilder class is a part of the java.lang package that provides a mutable sequence of characters. Unlike String (which is immutable), StringBuilder allows in-place modifications, making it memory-efficient and faster for frequent string operations.

Key points of the StringBuilder class

The key features of the StringBuilder class are listed below:

It offers similar functionality to StringBuffer, but without thread safety.
StringBuilder is not synchronized, making it faster and more efficient than StringBuffer in single-threaded applications.
Use StringBuffer only when thread safety is needed; otherwise, prefer StringBuilder for better performance.

Declaration:

StringBuilder sb = new StringBuilder("Initial String");

Example: Demonstration of a StringBuilder class in Java.

Java

public class Geeks
{
    public static void main(String[] args) {
        // Create a new StringBuilder with the initial content "GeeksforGeeks"
        StringBuilder sb = new StringBuilder("GeeksforGeeks");
        System.out.println("Initial StringBuilder: " + sb);

        // Append a string to the StringBuilder
        sb.append(" is awesome!");
        System.out.println("After append: " + sb);
    }
}

Output

Initial StringBuilder: GeeksforGeeks
After append: GeeksforGeeks is awesome!

Explanation:

In the above code, we first create a StringBuilder with the object sb and put the initial string as "GeeksforGeeks"
Then we use the append() method from StringBuilder class to add the " is awesome!" string in end of current StringBuilder object.

StringBuilder

StringBuilder Constructors

The StringBuilder class provides several constructors, which are listed below: Example: Creating a string using the StringBuilder Constructor StringBuilder(String str).

StringBuilder(): Creates an empty StringBuilder with a default initial capacity of 16 characters.
StringBuilder(int capacity): Creates an empty StringBuilder with a specified initial capacity. This is useful if you know the string will grow large.
StringBuilder(String str): Creates a StringBuilder initialized with the content of the given String.
StringBuilder(CharSequence cs): Creates a StringBuilder using the content of a given CharSequence object (like a String, StringBuffer, or any custom class implementing CharSequence).

Example:

Java

public class StringBuilderConstructorsDemo {
    public static void main(String[] args) {
        
        // 1. Default constructor (capacity = 16)
        StringBuilder sb1 = new StringBuilder();
        sb1.append("Hello");
        System.out.println("sb1: " + sb1);

        // 2. Constructor with capacity
        StringBuilder sb2 = new StringBuilder(50);
        sb2.append("This has initial capacity 50");
        System.out.println("sb2: " + sb2);

        // 3. Constructor with String input
        StringBuilder sb3 = new StringBuilder("Geeks");
        sb3.append("ForGeeks");
        System.out.println("sb3: " + sb3);

        // 4. Constructor with CharSequence input
        CharSequence cs = "Java";
        StringBuilder sb4 = new StringBuilder(cs);
        sb4.append("Programming");
        System.out.println("sb4: " + sb4);
    }
}

Output

GeeksforGeeks

Methods of StringBuilder class

The StringBuilder class provides several methods for creating and manipulating strings.

Example: Performing different String manipulation operations using StringBuilder methods such as appending, inserting, replacing, deleting, reversing and accessing characters.

Java

public class Geeks
{
    public static void main(String[] args) {

        // Create a new StringBuilder with the initial content "GeeksforGeeks"
        StringBuilder sb = new StringBuilder("GeeksforGeeks");
        System.out.println("Initial StringBuilder: " + sb);

        // 1. Append a string to the StringBuilder
        sb.append(" is awesome!");
        System.out.println("After append: " + sb);

        // 2. Insert a substring at a specific position
        sb.insert(13, " Java");
        System.out.println("After insert: " + sb);

        // 3. Replace a substring with another string
        sb.replace(0, 5, "Welcome to");
        System.out.println("After replace: " + sb);

        // 4. Delete a substring from the StringBuilder
        sb.delete(8, 14);
        System.out.println("After delete: " + sb);

        // 5. Reverse the content of the StringBuilder
        sb.reverse();
        System.out.println("After reverse: " + sb);

        // 6. Get the current capacity of the StringBuilder
        int capacity = sb.capacity();
        System.out.println("Current capacity: " + capacity);

        // 7. Get the length of the StringBuilder
        int length = sb.length();
        System.out.println("Current length: " + length);

        // 8. Access a character at a specific index
        char charAt5 = sb.charAt(5);
        System.out.println("Character at index 5: " + charAt5);

        // 9. Set a character at a specific index
        sb.setCharAt(5, 'X');
        System.out.println("After setCharAt: " + sb);

        // 10. Get a substring from the StringBuilder
        String substring = sb.substring(5, 10);
        System.out.println("Substring (5 to 10): " + substring);

        // 11. Find the index of a specific substring
        sb.reverse(); // Reversing back to original order for search
        int indexOfGeeks = sb.indexOf("Geeks");
        System.out.println("Index of 'Geeks': " + indexOfGeeks);

        // 12. Delete a character at a specific index
        sb.deleteCharAt(5);
        System.out.println("After deleteCharAt: " + sb);

        // 13. Convert the StringBuilder to a String
        String result = sb.toString();
        System.out.println("Final String: " + result);
    }
}

Output:

OutputStringBuilder

Explanation: In the above program, we use different methods of the StringBuilder class to perform different string manipulation operations such as append(), insert(), reverse() and delete().

Below is the list of methods in Java StringBuilder:

Method	Description	Example
append(String str)	Appends the specified string to the end of the StringBuilder.	sb.append("Geeks");
insert(int offset, String)	Inserts the specified string at the given position in the StringBuilder.	sb.insert(5, " Geeks");
replace(int start, int end, String)	Replaces characters in a substring with the specified string.	sb.replace(6, 11, "Geeks");
delete(int start, int end)	Removes characters in the specified range.	sb.delete(5, 11);
reverse()	Reverses the sequence of characters in the StringBuilder.	sb.reverse();
capacity()	Returns the current capacity of the StringBuilder.	int cap = sb.capacity();
length()	Returns the number of characters in the StringBuilder.	int len = sb.length();
charAt(int index)	Returns the character at the specified index.	char ch = sb.charAt(4);
setCharAt(int index, char)	Replaces the character at the specified position with a new character.	sb.setCharAt(0, 'G');
substring(int start, int end)	Returns a new String that contains characters from the specified range.	String sub = sb.substring(0, 5);
ensureCapacity(int minimum)	Ensures the capacity of the StringBuilder is at least equal to the specified minimum.	sb.ensureCapacity(50);
deleteCharAt(int index)	Removes the character at the specified position.	sb.deleteCharAt(3);
indexOf(String str)	Returns the index of the first occurrence of the specified string.	int idx = sb.indexOf("Geeks");
lastIndexOf(String str)	Returns the index of the last occurrence of the specified string.	int idx = sb.lastIndexOf("Geeks");
toString()	Converts the StringBuilder object to a String.	String result = sb.toString();

StringBuilder vs String vs StringBuffer

The table below demonstrates the difference between String, StringBuilder and StringBuffer:

Features	String	StringBuilder	StringBuffer
Mutability	String are immutable(creates new objects on modification)	StringBuilder are mutable(modifies in place)	StringBuffer are mutable (modifies in place)
Thread-Safe	It is thread-safe	It is not thread-safe	It is thread-safe
Performance	It is slow because it creates an object each time	It is faster (no object creation)	it is slower due to synchronization overhead
use Case	Fixed, unchanging strings	Single-threaded string manipulation	Multi-threaded string manipulation

Advantages

The advantages of the StringBuilder class are listed below:

It is more efficient than String when performing multiple string manipulations (like concatenation) since it modifies the string in place.
It avoids creating new objects on every modification, reducing memory overhead.
Unlike String, StringBuilder allows the modification of strings without creating new instances.
It dynamically adjusts its capacity as needed, minimizing the need for resizing.
Great for scenarios where strings are modified repeatedly inside loops.

Disadvantages

The disadvantages of the StringBuilder class are listed below:

It is not synchronized, making it unsuitable for use in multi-threaded environments.
If not used properly, StringBuilder may allocate excess memory, especially if the initial capacity is set too large.
For multi-threaded scenarios, you must handle synchronization manually, unlike StringBuffer.

StringBuilder and StringBuffer

Introduction to Java

R

RishabhPrabhu

Improve

Article Tags :

Practice Tags :

Similar Reads

Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems. It is known for its Write Once, Run Anywhere capability, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).Java s