DEV Community

Anush
Anush

Posted on • Edited on

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
    }
}
Enter fullscreen mode Exit fullscreen mode

Here's a summary of their characteristics:
Image description

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.

Top comments (0)