StringBuffer Java Example

In this example, we are going to present the StringBuffer class in Java, and StringBuffer vs StringBuilder which is contained in the java.lang package. We are going to show some of its most important uses and methods, and explain why and when it should be used, as well as the difference between StringBuffer and String.

1. String vs StringBuffer

Strings in Java are immutable. This means that when you instantiate a new String Object, you can not ever alter it. However, some of the most commonly seen code in Java happens to look like this:

String str = "hello";
str = str + " world";
//this prints "hello world"

So, what is going on here? Although it seems that we are appending to the String object, that in fact does not happen. What actually happens, is that the JVM creates a new StringBuffer object, which afterwards appends the different strings and in the end creates a new string, with a reference to the original. So essentially, we do not append a string to another, but we destroy the original String and use its variable to point to a whole new String (the concat of the first and the second one), which is also immutable.

Although it may seem that it is not a huge difference, it is in fact very important for optimization. While it is easier (and sometimes even advisable) to use the + operator for simplicity, when you have to do with a huge number of string concats you should try to use something like StringBuffer to make it faster. We will show the huge speed difference in the example later.

2. StringBuffer vs StringBuilder

Till Java 1.5 developers had a choice between String and StringBuffer. With Java 1.5 developers got a new option StringBuilder. In this section let us see the differences between StringBuffer and StingBuilder.

If you operate in a single-threaded environment or don’t care about thead-safety then use StringBuilder.

3. StringBuffer constructors

StringBuffer offers below different constructors:

4. StringBuffer Java Example

Below Example depicts the usage of StringBuffer,

public class StringBufferMain {

    public static void main(String[] args) {
        StringBuffer buffer = new StringBuffer();
        
        // Append the string representation of the argument to the end of the buffer.
        // In this example we use a string, but the method also accepts int, float,
        // double, boolean, char (or char[]), as well as objects.
        buffer.append("Hello World!");
        System.out.println(buffer.toString());
        
        // Delete the specified substring by providing the start and the end
        // of the sequence.
        buffer.delete(5, 11);
        System.out.println(buffer.toString());
        
        // Delete just one char by providing its position.
        buffer.deleteCharAt(5);
        System.out.println(buffer.toString());
        
        // Insert a string in a specified place inside the buffer.
        buffer.insert(0, "World ");
        System.out.println(buffer.toString());
        
        // Get the index that the specified substring starts at.
        System.out.println("Index of Hello: " + buffer.indexOf("Hello"));
        System.out.println(); // Empty line
        
        
        
        // You can also instantiate a new StringBuffer and provide
        // the initial String in the constructor.
        StringBuffer newBuffer = new StringBuffer("This is a Hello World string. Hello!");
        
        // You can use lastIndexOf(String) to get the last time that a specified
        // substring appears in the StringBuffer.
        System.out.println("Index of Hello: " + newBuffer.indexOf("Hello"));
        System.out.println("Last index of Hello: " + newBuffer.lastIndexOf("Hello"));
        
        // You can also replace a specific sub-sequence of the StringBuffer with another string.
        // The size does not need to be the same, as shown here.
        newBuffer.replace(0, 4, "That here");
        System.out.println(newBuffer.toString());
        
        // You can replace a single char using this method here. We want to
        // replace the last character of the string, so instead of counting the length,
        // we will use the provided length() method, and replace the char in the last index.
        newBuffer.setCharAt(newBuffer.length() - 1, '?');
        System.out.println(newBuffer.toString());
        
        // You can reverse the StringBuffer as well!
        newBuffer.reverse();
        System.out.println(newBuffer.toString());
        
        
        compareTime();
    }

    private static void compareTime() {
        long startTime;
        String str = "";
        StringBuffer buffer = new StringBuffer();
        
        // Using String
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            str += "extra";
        }
        System.out.println("Time using String: "
                + (System.currentTimeMillis() - startTime) + " ms.");
        
        // Using StringBuffer
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            buffer.append("extra");
        }
        System.out.println("Time using StringBuffer: "
                + (System.currentTimeMillis() - startTime) + " ms.");
    }
}

The first thing that you need to draw your attention to is the time output (the last 2 lines). You can see an enormous difference in time, which makes it pretty clear that Stringbuffer is the recommended approach when you have to deal with a large number of strings (in our example it is 10000). 488 ms vs. 2 ms makes a whole lot of a difference, especially in heavy applications, where 10000 strings might be the minimum threshold.

Secondly, let’s take a look at some of the most interesting and important StringBuffer methods, which were used in the example:

• append(String str): This method is used to add a string in the end of the StringBuffer. You can also use other versions of this method, such as append(int), where the String representation of the int will be added.
• delete(int start, int finish): Delete the specified substring from the StringBuffer.
• deleteCharAt(int position): Delete the character at the specified position.
• setCharAt(int position, char c): Replace a character in the StringBuffer.
• insert(int start, String str): insert a new string anywhere you want in the StringBuffer, by using the first argument of the method as the starting position of the new string.
• replace(int start, int finish, String str): You can replace a whole substring with another string in the StringBuffer. The inserted string does not need to be of the same size, which makes this method incredibly useful.
• reverse(): Reverses the whole StringBuffer (first character becomes last etc).

Of course, there are many more methods and functionality, but more or less most of them are variations of the ones presented here. By having the above methods in mind you can make use of all the important parts of StringBuffer and make your String manipulation faster, more optimized and simpler in many cases.

5. Download the source code

This was an example of StringBuffer use in Java.

Last updated on May 25th, 2020

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

and many more ....

I agree to the Terms and Privacy Policy

Sign up

Thank you!

We will contact you soon.