StringBuffer Vs StringBuilder in Java

In Java, StringBuffer and StringBuilder are java.lang package classes used to represent a sequence of characters. Both classes are similar in many ways, such as that both are mutable (changeable) strings and, by default, final classes, etc.

Apart from the similarities, there are many differences between the StringBuffer and StringBuilder in Java, which are given below.

👉 StringBuffer

StringBuffer is a mutable, final, and synchronized (thread-safe) Java class that was introduced in the JDK 1.0 version and is available in the java.lang package.

The StringBuffer class is used to create a mutable String object (the object can be changed once created). StringBuffer is similar to the String class except for one major difference: StringBuffer is mutable, whereas String is immutable (an object cannot be changed once it is created).

The StringBuffer class is thread-safe, which means that at any time, multiple threads cannot access it simultaneously. So it is safe and will result in order, but implementing the synchronization mechanism will take some time for the JVM, which is why StringBuffer is a little slower than StringBuilder.

public final class StringBuffer
extends Object
implements Serializable, Comparable <StringBuffer>, CharSequence

👉 StringBuilder

StringBuilder is mutable, non-synchronized, and a final class in Java. It was introduced in the JDK 1.5 version and placed in the java.lang package.

StringBuilder is used to create a mutable string object, which means we can modify the string without creating a new object. StringBuilder provides no guarantee of thread safety as it is non-synchronized at a time when multiple threads can access the StringBuilder object.

public final class StringBuilder extends Object
implements Serializable, CharSequence

👉 StringBuffer and StringBuilder have the following differences:

👉 Example of StringBuffer and StringBuilder in Java

Example 1: A sample Java program of StringBuffer

StringBuffer	StringBuilder

The StringBuffer object is thread-safe and synchronized. Multiple threads cannot call the methods of StringBuffer simultaneously.	The StringBuilder object is not synchronized and is not thread-safe. Multiple threads can call the methods of StringBuilder simultaneously.

StringBuffer is suitable for multi-threaded environments.	StringBuilder is suitable for single-threaded environments.

StringBuffer performance is slower as compared to StringBuilder.	StringBuilder performance is faster as compared to StringBuffer.

StringBuffer has been available since the JDK 1.0 version.	StringBuilder has been available since JDK Version 5.

  
  public class StringBufferDemo {
    public static void main(String[] args) {
      StringBuffer buffer = new StringBuffer("Welcome in StringBuffer Class");
      System.out.println(buffer);
    }
  }

Example 2: A sample Java program of StringBuilder

  
  public class StringBuilderDemo {
    public static void main(String[] args) {
      StringBuilder sb = new StringBuilder("Welcome in StringBuilder Class");
          System.out.println(sb);
    }
  }

Performance Test of StringBuffer and StringBuilder

One of the major differences between StringBuffer and StringBuilder is the performance. StringBuffer is a little slower than StringBuilder because StringBuffer methods are synchronized, while StringBuilder methods are not.

Let's check the performance of the StringBuffer and StringBuilder classes with the help of the given example.

  
  public class PerformanceTest {
    public static void main(String[] args) {
      long startTime = System.currentTimeMillis();
      StringBuffer buffer = new StringBuffer("Java");
  
      // appending string 10,000 times in the StringBuffer instance
      for (int i = 0; i < 10000; i++) {
        buffer.append("ByTechie");
      }
      System.out.println("Time taken by StringBuffer: " + 
                                    (System.currentTimeMillis() - startTime) + "ms");
  
      startTime = System.currentTimeMillis();
      StringBuilder builder = new StringBuilder("Java");
  
      // appending string 10,000 times in the StringBuilder instance
      for (int i = 0; i < 10000; i++) {
        builder.append("ByTechie");
      }
      System.out.println("Time taken by StringBuilder: " + 
                                    (System.currentTimeMillis() - startTime) + "ms");
    }
  }

Convert StringBuffer to StringBuilder in Java:

To convert StringBuffer to StringBuiler, first we need to convert StringBuffer to a String object by using the toString() method, and then we will create StringBuilder and pass the String object into the constructor.

  
  public class ConvertBufferToBuilder {
    public static void main(String[] args) {
      StringBuffer buffer = new StringBuffer("JavaByTechie");
  
      // STEP: 1
      // Conversion from StringBuffer object to the String object
      String str = buffer.toString();
  
      // STEP: 2
      // Creating a StringBuilder and passing String object (str) into the constructor
      StringBuilder builder = new StringBuilder(str);
  
      System.out.println("StringBuilder value: " + builder);
    }
  }

Convert StringBuilder to StringBuffer in Java:

Same as StringBuffer to StringBuiler conversion process, first we need to convert StringBuilder to a String object by using the toString() method, and then we will create StringBuffer and pass the String object into the constructor.

  public class ConvertBuilderToBuffer {
    public static void main(String[] args) {
      StringBuilder builder = new StringBuilder("JavaByTechie");
  
      // STEP: 1
      // Conversion from StringBuilder object to the String object
      String str = builder.toString();
  
      // STEP: 2
      // Creating a StringBuffer and passing String object (str) into the constructor
      StringBuffer buffer = new StringBuffer(str);
  
      System.out.println("StringBuffer value: " + buffer);
    }
  }