A Complete Guide - Java Programming StringBuffer vs StringBuilder

1. Overview of StringBuffer and StringBuilder

• StringBuffer: Is synchronized, meaning it is thread-safe and can be used by multiple threads without external synchronization.
• StringBuilder: Not synchronized, meaning it is not thread-safe and should not be used by multiple threads concurrently. It performs better than StringBuffer because of its non-synchronized nature.

2. Creating Instances

Using StringBuffer:

public class Main {
    public static void main(String[] args) {
        // Create a StringBuffer instance
        StringBuffer buffer = new StringBuffer();
        
        // Append text to the buffer
        buffer.append("Hello");
        buffer.append(" ");
        buffer.append("World");
        
        // Display the content of the buffer
        System.out.println(buffer.toString());  // Output: Hello World
    }
}

Explanation:

• We declare a StringBuffer object named buffer.
• We use the append method to add different parts of the string (e.g., words, spaces).
• Finally, we convert the StringBuffer to a string using toString() and print it.

Using StringBuilder:

public class Main {
    public static void main(String[] args) {
        // Create a StringBuilder instance
        StringBuilder builder = new StringBuilder();
        
        // Append text to the builder
        builder.append("Hello");
        builder.append(" ");
        builder.append("World");
        
        // Display the content of the builder
        System.out.println(builder.toString());  // Output: Hello World
    }
}

Explanation:

• This example is almost identical to the one above but uses StringBuilder instead of StringBuffer.
• Both classes have similar methods like append, insert, delete, etc.

3. Inserting Text

Using StringBuffer:

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("Hello World");

        // Insert text before the word "World"
        buffer.insert(5, " Beautiful");
        
        // Now display the content of the buffer
        System.out.println(buffer.toString());  // Output: Hello Beautiful World
    }
}

Using StringBuilder:

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("Hello World");

        // Insert text before the word "World"
        builder.insert(5, " Beautiful");
        
        // Now display the content of the builder
        System.out.println(builder.toString());  // Output: Hello Beautiful World
    }
}

Explanation:

• In both examples, we start with an initialized string ("Hello World").
• Using the insert method, we add the word "Beautiful" at index position 5.
• This shifts all subsequent characters to the right while inserting the specified sequence of characters.

4. Deleting Text

Using StringBuffer:

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("Hello Beautiful World");

        // Delete the word "Beautiful"
        buffer.delete(6, 17);
        
        // Now display the content of the buffer
        System.out.println(buffer.toString());  // Output: Hello  World
    }
}

Using StringBuilder:

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("Hello Beautiful World");

        // Delete the word "Beautiful"
        builder.delete(6, 17);
        
        // Now display the content of the builder
        System.out.println(builder.toString());  // Output: Hello  World
    }
}

Explanation:

• In this example, we delete a portion of the string starting from index 6 to 17.
• Indices are inclusive at the start and exclusive at the end — so it deletes all characters from index 6 to 16 ("Beautiful ").

5. Reversing the String

Using StringBuffer:

public class Main {
    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer("Hello Java!");

        // Reverse the string buffer
        buffer.reverse();
        
        // Now display the content of the buffer
        System.out.println(buffer.toString());  // Output: !avaJ olleH
    }
}

Using StringBuilder:

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder("Hello Java!");

        // Reverse the string builder
        builder.reverse();
        
        // Now display the content of the builder
        System.out.println(builder.toString());  // Output: !avaJ olleH
    }
}

Explanation:

• Both classes offer a reverse method that reverses the sequence of characters.

6. Performance Comparison

To see the performance difference between StringBuffer and StringBuilder, we can run a simple benchmark that appends a large number of strings.

public class BenchmarkAppendingStrings {
    public static void main(String[] args) {
        long startTime, endTime;
        
        // Benchmarking StringBuffer
        startTime = System.nanoTime();
        StringBuffer stringBuffer = new StringBuffer();
        for (int i = 0; i < 100000; i++) {
            stringBuffer.append("a");
        }
        endTime = System.nanoTime();
        System.out.println("StringBuffer took " + (endTime - startTime) / 1_000_000 + " ms to append 100,000 characters.");
        
        // Benchmarking StringBuilder
        startTime = System.nanoTime();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            stringBuilder.append("a");
        }
        endTime = System.nanoTime();
        System.out.println("StringBuilder took " + (endTime - startTime) / 1_000_000 + " ms to append 100,000 characters.");
    }
}

Explanation:

• We initialize a StringBuffer and a StringBuilder.
• We append the letter "a" one hundred thousand times to each of them.
• We time the operations using System.nanoTime() to get the duration in milliseconds.
• Typically, you will observe that StringBuilder takes less time compared to StringBuffer due to reduced synchronization overhead.

7. Conclusion

• Use StringBuffer when your application is multi-threaded and requires thread safety.
• Use StringBuilder when your application is single-threaded as it provides better performance.