Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/stringbuilder-class-in-java-with-examples/ below:

StringBuilder Class in Java - GeeksforGeeks

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.

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");

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.

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

1. StringBuilder(): Creates an empty StringBuilder with a default initial capacity of 16 characters.
2. StringBuilder(int capacity): Creates an empty StringBuilder with a specified initial capacity. This is useful if you know the string will grow large.
3. StringBuilder(String str): Creates a StringBuilder initialized with the content of the given String.
4. 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:

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);
    }
}

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.

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

Below is the list of methods in Java StringBuilder:

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

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.

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.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4