Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/string-vs-stringbuilder-vs-stringbuffer-in-java/ below:

String vs StringBuilder vs StringBuffer in Java

Last Updated : 23 Jul, 2025

A string is a sequence of characters. In Java, String objects are immutable, which simply means once created, their values can not be changed. In Java, String, StringBuilder, and StringBuffer are used for handling strings. The main difference is:

• String: Immutable, meaning its value cannot be changed once created. It is thread-safe but less memory-efficient.
• StringBuilder: Mutable, not thread-safe, and more memory-efficient compared to String. Best used for single-threaded operations.
• StringBuffer: Mutable and thread-safe due to synchronization, but less efficient than StringBuilder in terms of performance.

Features

String

StringBuilder

StringBuffer

Introduction

Introduced in JDK 1.0

Introduced in JDK 1.5

Introduced in JDK 1.0

Mutability

Immutable

Mutable

Mutable

Thread Safety

Thread Safe

Not Thread Safe

Thread Safe

Memory Efficiency

High

Efficient

Less Efficient

Performance

Can be slower for many concatenations

High(No-Synchronization)

Low(Due to Synchronization)

Usage

This is used when we want immutability.

This is used when Thread safety is not required.

This is used when Thread safety is required.

Let us consider the code below with three concatenation functions with three different types of parameters, String, StringBuffer, and StringBuilder. Let us clear out the understanding between them via a single Java program below, from which we will be drawing out conclusions from the output generated, to figure out the main differences between String vs StringBuilder, vs StringBuffer in Java.

Example:

// Java program to demonstrate difference between
// String, StringBuilder and StringBuffer
class Geeks {

    // Method 1
    // Concatenates to String
    public static void concat1(String s1)
    {
        s1 = s1 + "forgeeks";
    }

    // Method 2
    // Concatenates to StringBuilder
    public static void concat2(StringBuilder s2)
    {
        s2.append("forgeeks");
    }

    // Method 3
    // Concatenates to StringBuffer
    public static void concat3(StringBuffer s3)
    {
        s3.append("forgeeks");
    }

    // Method 4
    // Main driver method
    public static void main(String[] args)
    {
        // Custom input string
        // String 1
        String s1 = "Geeks";

        // Calling above defined method
        concat1(s1);

        // s1 is not changed
        System.out.println("String: " + s1);

        // String 1
        StringBuilder s2 = new StringBuilder("Geeks");

        // Calling above defined method
        concat2(s2);

        // s2 is changed
        System.out.println("StringBuilder: " + s2);

        // String 3
        StringBuffer s3 = new StringBuffer("Geeks");

        // Calling above defined method
        concat3(s3);

        // s3 is changed
        System.out.println("StringBuffer: " + s3);
    }
}

String: Geeks
StringBuilder: Geeksforgeeks
StringBuffer: Geeksforgeeks

Explanation:

• Concat1: In this method, the string "Geeks" is passed, and we perform s1 = s1 + "forgeeks". Since String is immutable, a new string is created, and s1 in concat1() points to it. The original string in main() remains unchanged.
• Concat2: Here, s2.append("forgeeks") modifies the original StringBuilder object. Since StringBuilder is mutable, it updates the string directly in main() to "Geeksforgeeks".
• Concat3: StringBuffer and StringBuilder are similar, but StringBuffer is thread-safe due to synchronized methods, while StringBuilder is not, making it thread-unsafe.
   

Geeks now you must be wondering when to use which one, do refer below as follows:

• If a string is going to remain constant throughout the program, then use the String class object because a String object is immutable.
• If a string can change (for example: lots of logic and operations in the construction of the string) and will only be accessed from a single thread, using a StringBuilder is good enough.
• If a string can change and will be accessed from multiple threads, use a StringBuffer because StringBuffer is synchronous, so you have thread-safety.
• If you don't want thread-safety than you can also go with StringBuilder class as it is not synchronized.
  

Sometimes there is a need for converting a string object of different classes like String, StringBuffer, StringBuilder to one another. Below are some techniques to do the same. Let's cover all use cases as follows:

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

This one is an easy way out as we can directly pass the String class object to StringBuffer and StringBuilder class constructors. As the String class is immutable in java, so for editing a string, we can perform the same by converting it to StringBuffer or StringBuilder class objects.

Example:

// Java program to demonstrate conversion from
// String to StringBuffer and StringBuilder
public class Geeks {
  
    public static void main(String[] args) {
      
        // Custom input string
        String s = "Geeks";

        // Converting String object to StringBuffer object
        // by creating object of StringBuffer class
        StringBuffer sbr = new StringBuffer(s);

        // Reversing the string
        sbr.reverse();

        // Printing the reversed string
        System.out.println(sbr);

        // Converting String object to StringBuilder object
        StringBuilder sbl = new StringBuilder(s);

        // Adding it to string using append() method
        sbl.append("forGeeks");

        // Print and display the above appended string
        System.out.println(sbl);
    }
}

skeeG
GeeksforGeeks

Explanation: The above example shows how to convert a String into StringBuffer and StringBuilder. We are reversing the String using StringBuffer and then adds more text using StringBuilder.

This conversion can be performed using toString() method which is overridden in both StringBuffer and StringBuilder classes. Below is the Java program to demonstrate the same.

Note: While we use toString() method, a new String object(in Heap area) is allocated and initialized to the character sequence currently represented by the StringBuffer object, which means the subsequent changes to the StringBuffer object do not affect the contents of the String object. 

Example:

// Java Program to Demonstrate Conversion from
// String to StringBuffer and StringBuilder
public class Geeks {
   
    public static void main(String[] args) {
      
        // Creating objects of 
        // StringBuffer class
        StringBuffer sbr = new StringBuffer("Geeks");
        StringBuilder sbl = new StringBuilder("Hello");

        // Converting StringBuffer object to String
        // using toString() method
        String s1 = sbr.toString();

        // Printing the above string
        System.out.println(
            "StringBuffer object to String: ");
        System.out.println(s1);

        // Converting StringBuilder object to String
        String s2 = sbl.toString();

        // Printing the above string
        System.out.println(
            "StringBuilder object to String: ");
        System.out.println(s2);

        // Changing StringBuffer object sbr
        // but String object(s1) doesn't change
        sbr.append("ForGeeks");

        // Printing the above two strings on console
        System.out.println(sbr);
        System.out.println(s1);
    }
}

StringBuffer object to String: 
Geeks
StringBuilder object to String: 
Hello
GeeksForGeeks
Geeks

Explanation: The above example shows how to convert StringBuffer and StringBuilder objects into String with the help of toString() method.

This conversion is tricky. There is no direct way to convert the same. In this case, We can use a String class object. We first convert the StringBuffer/StringBuilder object to String using toString() method and then from String to StringBuilder/StringBuffer using constructors.

Example:

// Java program to Demonstrate conversion from
// String to StringBuffer and StringBuilder
public class Geeks {

    // Main driver method
    public static void main(String[] args) {
      
        // Creating object of StringBuffer class and
        // passing our input string to it
        StringBuffer sbr = new StringBuffer("Geek");

        // Storing value StringBuffer object in String and
        // henceforth converting StringBuffer object to
        // StringBuilder class
        String s = sbr.toString();
        StringBuilder sbl = new StringBuilder(s);

        System.out.println(sbl);
    }
}

Explanation: The above example shows how to convert a StringBuffer into a String and then converting the same String into a StringBuilder.

Note: From the above three use-cases we can conclude out below pointers: 

• Objects of String are immutable, and objects of StringBuffer and StringBuilder are mutable.
• StringBuffer and StringBuilder are similar, but StringBuilder is faster and preferred over StringBuffer for the single-threaded program. If thread safety is needed, then StringBuffer is used.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4