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)