StringBuffer in Java: What It Is and How to Use It

Key Points

• StringBuffer is a mutable option in Java that is faster than String.
• The main methods for modifying a StringBuffer are append, insert, and replace.
• StringBuffer and StringBuilder are alternatives to each other, with StringBuffer ensuring data consistency across multiple threads.

To begin, strings in Java are objects containing a set number of character values. However, the issue with them is that you can’t change the information in a string without creating a new one. So, since you need to change the data often, it can use a lot of resources. Consequently, you can use StringBuffer in Java as an alternative.

StringBuffer is a mutable option in Java that provides many of the functions of a string. Thus, it lets users store character data and change the information stored within the program. StringBuffer is also faster than String and uses fewer resources. So, it’s a useful alternative to the basic String. Let’s examine StringBuffer and learn how to use it in our code.

Key Features of StringBuffer

• StringBuffer allows you to store character data
• It’s a mutable function, meaning you can change the data without creating a new object
• StringBuffer uses fewer resources because it doesn’t create a new instance every time you change the data
• Multiple threads can access and modify StringBuffers simultaneously, and the data will be the same over all of those threads

Constructors

Methods for Modification of Strings

Several functions in Java can modify StringBuffer data to allow you to alter the information contained in the string. Thus, you’ll need to use these operations when you want to change the details in your code. So, the main methods you’ll use to change your string are append, insert, and replace.

You can use them to alter the data contained in your string to many different data types. We’ll cover all the different ways you can work with your information. So, the following tables contain the different methods that can modify StringBuffers.

Append

Insert

Replace

Delete

Returning Indexes

SubSequence and Substring

Set

CodePoint

Miscellaneous

Practical Examples

class Example1{  
public static void main(String args[]){  
StringBuffer example=new StringBuffer("Hello ");
example.append("World");   
System.out.println(example);  
}  
}

We’ll start by creating the class “example.” Additionally, We’ve set it so that main() is publically accessible, and we can call it without creating a class instance. Then, we create a StringBuffer and set its value to “Hello .” After that, we’re going to use the append method to add “World” to the String. So, this code outputs “Hello World.”

class Example2{  
public static void main(String args[]){  
StringBuffer example=new StringBuffer("Hello ");
example.insert(1,"World"); 
System.out.println(example);  
}  
} 

This script starts basically the same as the one before it. However, we’re going to use the insert method to add “World” at index 1 in the String. Thus, that code block outputs “HWorldello.”

class Example3{  
public static void main(String args[]){  
StringBuffer example=new StringBuffer("Hello");
example.replace(1,3,"World");   
System.out.println(example);  
}  
}  

In this example, our StringBuffer is set to “Hello.” Then, we use the replace method to replace all characters from indexes 1 to 3 with the word “World.” So, that one outputs “HWorldlo.”

class Example4{  
public static void main(String args[]){  
StringBuffer example=new StringBuffer("Hello World");
example.delete(1,3);//Deletes the data from index 1 to index 3
System.out.println(example);
}  
}

So, this script creates a StringBuffer that says “Hello World.” Then, we will use the delete method to delete the characters in the String from indexes 1 to 3. Thus, this one outputs “Hlo World.”

class Example5{  
public static void main(String args[]){  
StringBuffer example=new StringBuffer("Hello World");
example.reverse();
System.out.println(example);  
}  
}

To begin, this script creates a StringBuffer with the value “Hello World.” Then, we use the reverse method on it, which does exactly what it says on the tin. So, this block outputs “dlorW olleH.”

class Example6{  
public static void main(String args[]){  
StringBuffer example=new StringBuffer();  
System.out.println(example.capacity());  
example.append("Hello"); 
System.out.println(example.capacity()); 
example.append("Java is my favorite language");
System.out.println(example.capacity());
}  
}  

For starters, this program creates a StringBuffer with no value and a default capacity of 16. Then, we use the print function to print to output “example.capacity()” which puts it on the screen. After that, we append the String to say “World” instead.

However, this doesn’t change the capacity. Therefore, the second output will be the same. Now, the second append to “Java is my favorite language” is longer than 16 characters. When we do this, the character maximum of the String changes to (old capacity*2)+2 or (16*2)+2, so 34. So, that block outputs “16 16 34”.

class Example7{  
public static void main(String args[]){  
StringBuffer example=new StringBuffer();  
System.out.println(example.capacity());
example.append("Hello"); 
System.out.println(example.capacity());  
example.append("java is my favorite language");  
System.out.println(sb.capacity());
example.ensureCapacity(10); 
System.out.println(example.capacity());  
example.ensureCapacity(50); 
System.out.println(example.capacity());
}  
} 

To begin, this block will create a StringBuffer with no value and a default capacity of 16. Then, we’ll output that. After that, we’ll change the String data to “Hello” and output the capacity again, which hasn’t changed.

Now, we’ve changed the String to say “Java is my favorite language” and printed the new capacity of 34. After that, we’ll use the ensureCapacity to mandate that the minimum capacity is 10, which doesn’t change anything. Then we print the capacity again.

Finally, we’ve used ensureCapacity again, but, this time, we’ve set the capacity to 50 which is more than the current 34. So, the program will update the capacity again and (34*2)+2 is 70 which is more than 50. Thus, this block outputs “16 16 34 34 70”.

StringBuffer vs. StringBuilder: What’s the Difference?

However, StringBuffer is not always necessary. Consequently, StringBuilder is a drop-in alternative for StringBuffer. Still, they differ mostly in whether the data will remain the same over multiple threads. StringBuffer ensures the data will remain the same when multiple threads use the String, while StringBuilder does not. Therefore, you can use StringBuilder when only one thread at a time uses the information. 

Most of the time, only one thread uses a string at any given time. So, you should use StringBuilder instead of StringBuffer wherever possible. However, if you know multiple threads will access a String, you should use StringBuffer.

The image featured at the top of this post is ©Trismegist san/Shutterstock.com.