What’s the difference between StringBuilder and StringBuffer in Java ?

The primary differences between StringBuilder and StringBuffer in Java revolve around thread safety and performance. Here’s a detailed breakdown:

1. Thread Safety

• StringBuffer:
• Thread-safe: All its methods are synchronized (use intrinsic locks).
• Safe for use in multi-threaded environments where multiple threads might modify the same buffer.
• Example:

StringBuffer buffer = new StringBuffer(); 
buffer.append("Hello"); // Synchronized call

• StringBuilder:
• Not thread-safe: Methods are not synchronized.
• Designed for single-threaded use where performance is prioritized over thread safety.
• Example:

StringBuilder builder = new StringBuilder(); 
builder.append("World"); // Non-synchronized call

2. Performance

• StringBuilder is faster than StringBuffer because it avoids synchronization overhead.
• Benchmark Example:

  // Test with 100,000 appends in a single thread:
  StringBuilder: ~5 ms  
  StringBuffer:  ~50 ms (10x slower due to synchronization)

3. When to Use Which

Scenario	Use Case	Recommended Class
Single-threaded environment	Local variables, methods	StringBuilder
Multi-threaded environment	Shared across threads	StringBuffer or external synchronization

4. API and Functionality

Both classes inherit from AbstractStringBuilder and provide identical methods (e.g., append(), insert(), reverse()). The only difference is synchronization in StringBuffer.

5. Historical Context

• StringBuffer: Introduced in Java 1.0.
• StringBuilder: Added in Java 5 (J2SE 5.0) to address performance issues in single-threaded scenarios.

Example Code Comparison

Single-Threaded Use (Prefer StringBuilder):

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("Java");
System.out.println(sb); // Output: "Hello Java"

Multi-Threaded Use (Requires StringBuffer):

StringBuffer buffer = new StringBuffer();
Runnable task = () -> buffer.append("ThreadSafe ");
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(task);
executor.submit(task);
executor.shutdown();
System.out.println(buffer); // Output: "ThreadSafe ThreadSafe "

Key Takeaways

1. Default Choice: Use StringBuilder unless thread safety is explicitly required.
2. Legacy Code: Replace StringBuffer with StringBuilder in single-threaded code for better performance.
3. Synchronization Overhead: Avoid StringBuffer in performance-critical paths.

By understanding these differences, you can optimize both correctness and efficiency in your Java applications.