StringBuffer Class in Java

The StringBuffer class in Java represents a sequence of characters that can be modified, which means we can change the content of the StringBuffer without creating a new object every time. It represents a mutable sequence of characters.

Features of StringBuffer Class

The key features of StringBuffer class are listed below:

• Unlike String, we can modify the content of the StringBuffer without creating a new object.
• All methods of StringBuffer are synchronized, making it safe to use in multithreaded environments.
• Ideal for scenarios with frequent modifications like append, insert, delete, or replace operations.

Example: Here is an example of using StringBuffer to concatenate strings:

public class Geeks {
    public static void main(String[] args){
      
      	// Creating StringBuffer
        StringBuffer s = new StringBuffer();
      
      	// Adding elements in StringBuffer
        s.append("Hello");
        s.append(" ");
        s.append("world");
        
      	// String with the StringBuffer value
      	String str = s.toString();
        System.out.println(str);
    }
}

Hello world

Constructors of StringBuffer Class

1. StringBuffer(): It reserves room for 16 characters without reallocation
2. StringBuffer(int size): It accepts an integer argument that explicitly sets the size of the buffer.
3. StringBuffer(String str): It accepts a string argument that sets the initial contents of the StringBuffer object and reserves room for 16 more characters without reallocation.

Example:

public class Geeks {
    public static void main(String[] args) {

        // 1. Using default constructor
        StringBuffer sb1 = new StringBuffer();
        sb1.append("Hello");
        System.out.println("Default Constructor: " + sb1);

        // 2. Using constructor with specified capacity
        StringBuffer sb2 = new StringBuffer(50);
        sb2.append("Java Programming");
        System.out.println("With Capacity 50: " + sb2);

        // 3. Using constructor with String
        StringBuffer sb3 = new StringBuffer("Welcome");
        sb3.append(" to Java");
        System.out.println("With String: " + sb3);
    }
}

Default Constructor: Hello
With Capacity 50: Java Programming
With String: Welcome to Java

Implementation of Java StringBuffer Method

1. append() Method

append() method concatenates the given argument with this string.

Example: 

import java.io.*;

class Geeks {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer("Hello ");
        sb.append("Java"); // now original string is changed
        System.out.println(sb);
    }
}

Hello Java

2. insert() Method

insert() method inserts the given string with this string at the given position. 

Example:

import java.io.*;

class Geeks {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer("Hello ");
        sb.insert(1, "Java");
        
        // Now original string is changed
        System.out.println(sb);
    }
}

HJavaello 

3. replace() Method

replace() method replaces the given string from the specified beginIndex and endIndex-1.

Example: 

import java.io.*;

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

HJavalo

4. delete() Method

delete() method is used to delete the string from the specified beginIndex to endIndex-1.

Example:

import java.io.*;

class Geeks {
    public static void main(String args[]) {
      
        StringBuffer sb = new StringBuffer("Hello");
        sb.delete(1, 3);
        System.out.println(sb);
    }
}

Hlo

5. reverse() Method

reverse() method of the StringBuffer class reverses the current string. 

Example: 

import java.io.* ;

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

olleH

6. capacity() Method

• capacity() method of the StringBuffer class returns the current capacity of the buffer. The default capacity of the buffer is 16. If the number of characters increases from its current capacity, it increases the capacity by (oldcapacity*2)+2.
• For example, if the current capacity is 16, it will be (16*2)+2=34.

Example: 

import java.io.*;

class Geeks {
    public static void main(String args[])
    {
        StringBuffer sb = new StringBuffer();
      
      	// default 16
        System.out.println(sb.capacity()); 
        sb.append("Hello");
      
      	// now 16
        System.out.println(sb.capacity()); 
        sb.append("java is my favourite language");
        
      	// (oldcapacity*2)+2
      	System.out.println(sb.capacity());
    }
}

16
16
34

7. length()

This method return the number of character in given string.

import java.io.*;

class Geeks {
    public static void main(String[] args) {

        // Creating and storing string by creating object of StringBuffer
        StringBuffer s = new StringBuffer("GeeksforGeeks");

        // Getting the length of the string
        int p = s.length();

        // Getting the capacity of the string
        System.out.println("Length of string GeeksforGeeks=" + p);
    } 
}

Length of string GeeksforGeeks=13

Advantages of using StringBuffer

The advanatages of StringBuffer class are listed below:

• Mutable: StringBuffer are mutable it means that we can change the content after the object has been created, on the other hand String are immutable once it created it can not be modified.
• Efficient: Since StringBuffer objects are mutable, it is suitable in scenarios where we need to modify the string multiple times. If we do the same thing with string, everytime a new object is created and the old one is deleted, which is very bad in terms of performance and memory.

Note: Both String and StringBuffer objects are thread safe, but in different ways. On the other hand immutable objects like String are thread-safe because their state can not be modified once they are created.

Disadvantage of StringBuffer

• Slower in single-threaded programs: It's synchronized, meaning it ensures thread safety by allowing only one thread to access it at a time. However, in single-threaded environments, this synchronization is unnecessary and slows down performance compared to non-synchronized classes like StringBuilder.
• Less efficient than StringBuilder: For non-threaded use cases, StringBuilder is faster and has similar functionality. Also, StringBuffer operations like append() or insert() make the code longer compared to using simple '+' with String.

Summary Table of StringBuffer Methods

The table below describes all the methods of the StringBuffer class

StringBuilder and StringBuffer

Visit Course