A simple comparison of String, StringBuffer, and StringBuilder:

Feature	`String`	`StringBuffer`	`StringBuilder`
Mutability	Immutable (cannot be changed)	Mutable (can be modified)	Mutable (can be modified)
Thread Safety	Not applicable (immutable)	Synchronized (thread-safe)	Not synchronized (not thread-safe)
Performance	Slower for frequent changes	Slower than `StringBuilder` due to synchronization	Faster for frequent changes
Use Case	Use when the value does not change frequently	Use when thread safety is needed and value changes frequently	Use when thread safety is not needed and value changes frequently
Memory	Uses more memory due to creation of new objects for each change	Uses less memory for modifications compared to `String`	Uses less memory for modifications compared to `String`
Common Methods	`concat()`, `toUpperCase()`, `toLowerCase()`	`append()`, `insert()`, `delete()`	`append()`, `insert()`, `delete()`

String: Immutable and used when the value doesn’t change. Slower for modifications due to creating new objects.
StringBuffer: Mutable and thread-safe, suitable for cases where thread safety is needed. Slightly slower due to synchronization.
StringBuilder: Mutable and not thread-safe, ideal for single-threaded scenarios where frequent changes are needed. Faster and more efficient for such use cases.

String v/s StringBuffer v/s StringBuilder.