Differentiating String, StringBuffer, and StringBuilder in Java

How would you differentiate between a String, StringBuffer, and a StringBuilder?

In Java, String, StringBuffer, and StringBuilder are all classes used to handle strings, but they have different characteristics and use cases. Here’s a breakdown of their differences:

1. String

• Immutability: String objects are immutable, meaning once a String is created, it cannot be changed. Any modification to a String results in the creation of a new String object.
• Performance: Because of immutability, frequent modifications (like concatenation) can lead to performance issues, as new objects are created each time.
• Usage: Use String when you have a fixed set of characters that do not change, or when you are performing a small number of modifications.

Example:

String str = "Hello";
str = str + " World"; // Creates a new String object

2. StringBuffer

• Mutability: StringBuffer objects are mutable, meaning you can modify the contents of a StringBuffer without creating a new object.
• Thread Safety: StringBuffer is synchronized, making it thread-safe. This means that it can be safely used in a multi-threaded environment.
• Performance: While it is more efficient than String for multiple modifications, the synchronization can introduce overhead, making it slower than StringBuilder in single-threaded scenarios.
• Usage: Use StringBuffer when you need a mutable string in a multi-threaded environment.

Example:

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World"); // Modifies the existing StringBuffer object

3. StringBuilder

• Mutability: Like StringBuffer, StringBuilder objects are mutable.
• Thread Safety: StringBuilder is not synchronized, which means it is not thread-safe. This makes it faster than StringBuffer in single-threaded scenarios.
• Performance: Generally, StringBuilder is preferred for string manipulation in a single-threaded context due to its better performance.
• Usage: Use StringBuilder when you need a mutable string and you are sure that the code will not be accessed by multiple threads simultaneously.

Example:

StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // Modifies the existing StringBuilder object

Summary

• String: Immutable, not thread-safe, use for fixed strings or few modifications.
• StringBuffer: Mutable, thread-safe, use for mutable strings in multi-threaded environments.
• StringBuilder: Mutable, not thread-safe, use for mutable strings in single-threaded environments.

Choosing the right one depends on your specific use case, particularly regarding mutability and thread safety.