String Vs StringBuffer Vs StringBuilder in Java 💪

String, StringBuffer, and StringBuilder are three classes used for string manipulation, but they differ in terms of mutability, synchronization, and performance characteristics:

String:

• Immutable: Once a String object is created, its value cannot be changed.
• Thread-safe: Immutable strings are inherently thread-safe.
• Memory efficiency: Because strings are immutable, modifying them (e.g., concatenation) creates new string objects, potentially leading to memory overhead, especially in scenarios with frequent string manipulation.
• Suitable for scenarios where the value of the string remains constant or changes infrequently.

StringBuffer:

• Mutable: StringBuffer objects can be modified after creation.
• Thread-safe: StringBuffer methods are synchronized, making them safe for use in multithreaded environments.
• Performance: Slower than StringBuilder due to synchronization.
• Suitable for scenarios where thread safety is required, such as in multithreaded applications or when concurrent access to strings is necessary

StringBuilder:

• Mutable: StringBuilder objects can be modified after creation.
• Not thread-safe: StringBuilder methods are not synchronized, making them unsuitable for concurrent use in multithreaded environments.
• Performance: Faster than StringBuffer because it lacks synchronization overhead.
• Suitable for single-threaded scenarios where high-performance string manipulation is required, such as string concatenation within loops or when building strings dynamically.

public class StringExample {
    public static void main(String[] args) {
        // Example of String
        String str = "Hello";
        str += " World"; // Concatenating " World" to the original string
        System.out.println("String: " + str); // Output: Hello World

        // Example of StringBuffer
        StringBuffer stringBuffer = new StringBuffer("Hello");
        stringBuffer.append(" World"); // Appending " World" to the original string
        System.out.println("StringBuffer: " + stringBuffer.toString()); // Output: Hello World

        // Example of StringBuilder
        StringBuilder stringBuilder = new StringBuilder("Hello");
        stringBuilder.append(" World"); // Appending " World" to the original string
        System.out.println("StringBuilder: " + stringBuilder.toString()); // Output: Hello World
    }
}

Here's a summary of their characteristics:

In summary, String is immutable and thread-safe, StringBuffer is mutable and thread-safe, and StringBuilder is mutable but not thread-safe. You should choose the appropriate class based on your specific requirements for mutability, thread safety, and performance.