StringBuffer vs. StringBuilder: Difference Between StringBuffer & StringBuilder

When programming in Java, Strings are one of the most used classes. A String is an object which is used when you want to represent a sequence of characters. They have several properties, and one of them is immutability, which means that they cannot be modified. String Buffers and String Builders were introduced in Java to tackle this. Using these classes, modifications can be done over and over again.

In this article, We’ll be going through both these classes and discussing the differences between them. Before diving into the classes, we shall familiarize ourselves with the concept of strings in Java.

Check out our free courses to get an edge over the competition.

Strings in Java

Strings are used in Java to store a sequence of character values. They are treated as objects in the Java programming language. We have various options to create and manipulate strings.

To create a string, the basic syntax is as follows:

String sentence = “Hello, world!”;

Strings have some properties, and one of them is that they are immutable, which means that they cannot be modified. But what if you want a string that can be modified. To do so, Java modifications called String Buffers and String Builders are used. Now that we have an understanding of what strings are, we shall proceed with our comparison.

Must Read: Java Project Ideas & Topics

Learn Software Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Check out upGrad’s Java Bootcamp.

StringBuffer

String Buffer is a class modification used in Java to add more functionality to the strings by giving characteristics like mutability. We can use methods like append(), insert(), reverse(), replace(), etc. to modify strings. StringBuffer has four defined constructors; they are as follows:

• StringBuffer(): This creates an empty string buffer with no characteristics with 16 characters’ capacity.
• StringBuffer(CharSequence chars): It creates a StringBuffer containing the same characters as the specified CharSequence.
• StringBuffer(int size): This constructs a StringBuffer with no characters with a specified initial capacity.
• StringBuffer(String str): It creates a StringBuffer object with an initially specified string.

Check out upGrad’s Advanced Certification in DevOps

Let us discuss some of the different methods we can use in StringBuffer to modify a particular string:

• Length () and capacity(): The current length of a StringBuffer can be found with the help of length() method while to find the total capacity, we use capacity() method.
• append(): The append() method is used to concatenate the string with other or similar data types. We can append strings, numbers, and objects to a string using this method.
• Insert (): This method is used to insert one string into another string.
• charAt(): This method is used to find the value of a single character in a StringBuffer.

We can see how we can use StringBuffer to modify strings according to our needs. So why do we use StringBuilder when we can get such functionality with StringBuffer?

Learn: Top 20 Trending Android Project Ideas & Topics For Beginners

StringBuilder

StringBuilder in Java is a sequence of mutable characters. StringBuilder provides an alternate class to make strings that can be modified as we know that strings are immutable. It is very similar to StringBuffer, but where these two differ is in the synchronization. StringBuilder is not synchronized, which in turn means it is not thread-safe. StringBuilder also has four defined constructors; they are as follows:

• StringBuilder(): It creates an empty StringBuilder with a room for 16 characters.
• StringBuilder(int size): It makes an empty string with a specified size.
• StringBuilder(CharSequence seq): It creates a StringBuilder containing the same characters as the specified CharSequence.
• StringBuilder(String str): Creates a String Builder object with an initially specified string str.

Let us discuss some of the methods we can use on StringBuilders:

• append(): This method is used when you want to append something to the string whether it is a string or a number or an object.
• Replace (): If you’re going to replace a string of characters from another set of characters, you can use the replace() method.
• Substring (): If you’re going to get a portion of a string you can obtain it by using the substring() method.

So as we can see that StringBuffer and StringBuilder seem to be the same. Even though they have similar functionality, they are quite different, and you might be better off using one rather than the other in many cases.

Differences between the two classes

Synchronization

By default, the StringBuffer is synchronized, whereas StringBuilder doesn’t have any synchronization. In cases where the string has to be accessed by multiple threads and no external synchronization is applied, you must use StringBuffer and not StringBuilder.

Thread-safe

StringBuilder is not a thread-safe class, whereas StringBuffer has this characteristic; this is due to the fact that StringBuffer is synchronized.

Speed

Due to the above two characteristics, StringBuffer is slower compared to StringBuilder. So if you want to have faster performance and don’t require the above characteristics, StringBuilder’s speed and efficiency make it a better choice.

 StringBuilder wad introduced in Java 1.5 by analyzing StringBuffer’s shortcoming and has enough changes that make it viable to use in certain situations where the former might take a hit on the performance.

Performance and Memory Consumption

As we can learn from the points above, StringBuilder is faster when it comes to performance compared to StringBuffer. Memory Consumption among the two is also different where StringBuffer consumes more memory compared to the latter.

Also Read: Top 130+ Java Interview Questions & Answers

Stringbuffer vs Stringbuilder

When several character-based String alterations are required, the StringBuffer and StringBuilder classes are employed. To know when to use what, we need to know Java StringBuilder vs. StringBuffer thoroughly.

Example of String Buffer

class Example_String_Buffer{  
public static void main(String args[]){  
StringBuffer sbe=new StringBuffer(“Lorem”);  
sbe.append(“Ipsum”); 
System.out.println(sbe);  
} }

Output – 

Lorem Ipsum

Example of StringBuilder

class Example_String_Builder{  
public static void main(String args[]){  
StringBuilder sbr=new StringBuilder(“Lorem”);  
sbe.append(“Ipsum”); 
System.out.println(sbr);  
} }

Output – 

Lorem Ipsum

Conversion Between Types Of Strings In Java

To better understand the difference between StringBuffer and StringBuilder, we also need to know their conversions. Techniques to convert a string object of different classes like StringBuffer, StringBuilder, and String to one another are as follows: 

• From StringBuffer to StringBuilder or vice-versa.
• From String to StringBuffer and StringBuilder. 
• From StringBuffer and StringBuilder to String.

Case 1: From StringBuffer to StringBuilder or vice-versa

It cannot be converted directly. The StringBuffer/StringBuilder object is first converted to a String using the toString() function, and then the String is converted back to a StringBuilder/StringBuffer object using constructors.

Case 2: From String to StringBuffer and StringBuilder 

This is an easy solution because the StringBuffer and StringBuilder class constructors can directly accept a String class object. Since the String class in Java is immutable, we can edit strings by converting them to StringBuilder or StringBuffer class objects.

Case 3: From StringBuffer and StringBuilder to String 

The toString() method, which is overridden in the StringBuilder and StringBuffer classes, can be used to convert data. 

String vs StringBuffer vs StringBuilder

These are some main difference between Java stringbuilder vs stringbuffer vs string.

• StringBuffer and StringBuilder are mutable classes, but String is immutable.
• StringBuilder is not synchronised or thread-safe, whereas StringBuffer is. StringBuilder is quicker than StringBuffer because of this.
• The StringBuffer or StringBuilder class is used internally by the string concatenation operator (+).
• Use StringBuilder instead of the StringBuffer class when manipulating strings in a single-threaded environment.

Performance Analysis

To check the performance of StringBuilder and StringBuffer, let us see an example with code:

public class Conc_Test{  
    public static void main(String[] args){  
  sTime = System.currentTimeMillis();  
        StringBuilder sb1 = new StringBuilder(“Lorem”);  
        for (int j=0; j<9999; j++){  
            sb1.append(“Ipsum”);  
        }  
        System.out.println(“StringBuilder Time: ” + (System.currentTimeMillis() – sTime)); 
        long sTime = System.currentTimeMillis();  
        StringBuffer sb2 = new StringBuffer(“Lorem”);  
        for (int j=0; j<9999; j++){  
            sb2.append(“Ipsum”);  
        }  
        System.out.println(“StringBuffer Time: ” + (System.currentTimeMillis() – sTime));  
           }  
}  

Output:

StringBuilder Time: 0ms

StringBuffer Time: 15ms

As we can acknowledge from the code above, StringBuilder performs better than StringBuffer in speed. Additionally, the memory consumption of the two differs, with StringBuffer using more memory than StringBuilder.

Wrapping up

Even though StringBuilder is classified as an alternative to the string class like StringBuffer, but it is a lot more flexible when it comes to usage.

So, As you can see that if you want to modify strings which by default are an immutable set of characters, you have to use StringBuffer or StringBuilder classes as they provide the ability to change strings. Both the classes are similar on the surface, as you can see, they use the same methods and similar constructors.

The difference between the two comes down to the synchronization and threading. If you are working in an environment where you don’t care about thread-safety, you can use StringBuilder as it will be a lot faster and efficient, but if you need thread safety, you should use StringBuffer as it is synchronized and thread-safe.

If you’re interested to learn more about Java, full-stack software development, check out upGrad & IIIT-B’s Executive PG Programme in Software Development – Specialisation in Cyber Security which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects, and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.