Java StringBuilder Class

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.

Declaration:

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

Key points of the StringBuilder class:

The key features of the StringBuilder class are listed below:

• StringBuilder in Java represents a mutable sequence of characters.
• String Class in Java creates an immutable sequence of characters, whereas StringBuilder creates a mutable sequence of characters, offering an alternative.
• The functionality of StringBuilder is similar to the StringBuffer class, as both provide mutable sequences of characters.
• StringBuilder does not guarantee synchronization, while StringBuffer does. It is a high-performance and low-overhead non thread non-thread-safe alternative to StringBuffer, suitable for single-threaded applications, while StringBuffer is used for synchronization in multithreaded applications.
• StringBuilder is faster than StringBuffer in most implementations.

Example: Demonstration of a StringBuilder class in Java.

// Demonstrating the usage of StringBuilder class
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);
    }
}

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.

Syntax of Java StringBuilder Class

The syntax of the StringBuilder class is listed below:

public final class StringBuilder extends Object implements Serializable, CharSequence

StringBuilder Class Hierarchy

java.lang.Object

↳ java.lang

↳ Class StringBuilder

Why Use StringBuilder in Java?

Using the StringBuilder class in Java has many benefits, which are listed below:

• Mutable: Unlike String, which creates a new object every time it's modified, StringBuilder allows you to change the string without creating new objects. This makes it more efficient for repeated modifications.
• Faster than String: StringBuilder doesn't create new objects for every change, it avoids unnecessary memory allocations, which makes it faster than String when performing many string manipulations.
• More Efficient than StringBuffer: In single-threaded environments, StringBuilder is more efficient than StringBuffer because it doesn't have the overhead of thread safety, which makes StringBuilder a better choice when we don't need synchronization.

StringBuilder vs String vs StringBuffer

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

StringBuilder Constructors

The StringBuilder class provides several constructors, which are listed below:

Example: Creating a string using the StringBuilder Constructor StringBuilder(String str).

// Creating a String using StringBuilder constructor
// StringBuilder(String str)
public class Geeks
{
    public static void main(String[] args) {
     
        // Creating a String using StringBuilder constructor
        // StringBuilder(String str)
        StringBuilder sb = new StringBuilder("GeeksforGeeks");
        
        // Converting StringBuilder to String
        String str = sb.toString();
        
        // Printing the String
        System.out.println(str);
    }
}

GeeksforGeeks

Methods of StringBuilder class

The StringBuilder class provides several methods for creating and manipulating strings, which are listed below:

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

// Demonstrating the usage of multiple StringBuilder methods like 
// append(), insert(), replace(), delete(), reverse(),
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:

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().

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.