What is the difference between string, StringBuilder, and StringBuffer?

In Java, string handling is a common task, and you can use String, StringBuilder, and StringBuffer for it. Each approach has distinct characteristics in functionality and performance:

1. String

• Immutability: In Java, String is immutable, meaning that once a String object is created, its value cannot be changed. Modifying a string creates a new String object.
• Performance Issues: Since modifying a string creates a new string each time, performance may be poor when modifications are frequent.
• Example: Consider a string operation where each operation appends a new character:

java
String s = "Hello";
s += " world";
s += "!";

2. StringBuilder

• Mutability: StringBuilder is mutable, allowing modifications without creating new objects.
• Not Thread-Safe: StringBuilder methods are not synchronized, so it is not thread-safe. However, in a single-threaded environment, it performs better than StringBuffer.
• Use Cases: Suitable for single-threaded scenarios where frequent string modifications are needed.
• Example: Using StringBuilder for the same string operation:

java
StringBuilder sb = new StringBuilder("Hello");
sb.append(" world");
sb.append("!");

3. StringBuffer

• Mutability: Similar to StringBuilder, StringBuffer is also mutable.
• Thread-Safe: StringBuffer methods are synchronized, making it safe for multi-threaded environments.
• Performance: Due to thread safety, its performance may be lower than StringBuilder.
• Use Cases: Suitable for multi-threaded environments where thread safety is required for string modifications.
• Example: Using StringBuffer for the same string operation:

java
StringBuffer sbf = new StringBuffer("Hello");
sbf.append(" world");
sbf.append("!");

Summary

• Choose String: When the string is not frequently modified or when modification operations are infrequent.
• Choose StringBuilder: For frequent string modifications in a single-threaded environment.
• Choose StringBuffer: For multi-threaded environments where thread safety is necessary.