String vs StringBuilder vs StringBuffer in Java

Comprehensive Comparison Table

Detailed Feature Comparison

Memory and Performance

Method Availability

Thread Safety Details

Memory Footprint Comparison

Performance Benchmarks

Concatenation Performance (10,000 operations)

Thread Safety Performance

Code Examples Comparison

Basic Usage

// String - Immutable
String str = "Hello";
str = str + " World";        // Creates new object
str = str + "!";             // Creates another new object
// Result: 3 objects created

// StringBuilder - Mutable, Not Thread-Safe
StringBuilder sb = new StringBuilder("Hello");
sb.append(" World");         // Modifies existing buffer
sb.append("!");              // Modifies same buffer
String result = sb.toString(); // Convert to String

// StringBuffer - Mutable, Thread-Safe
StringBuffer buffer = new StringBuffer("Hello");
buffer.append(" World");     // Synchronized method
buffer.append("!");          // Synchronized method
String result2 = buffer.toString();

Multi-threading Examples

// StringBuilder - NOT thread-safe
public class UnsafeExample {
    private StringBuilder sb = new StringBuilder();

    public void appendText(String text) {
        sb.append(text); // Race condition possible!
    }
}

// StringBuffer - Thread-safe
public class SafeExample {
    private StringBuffer buffer = new StringBuffer();

    public void appendText(String text) {
        buffer.append(text); // Thread-safe
    }
}

// Manual synchronization with StringBuilder
public class ManualSyncExample {
    private StringBuilder sb = new StringBuilder();
    private final Object lock = new Object();

    public void appendText(String text) {
        synchronized(lock) {
            sb.append(text); // Now thread-safe
        }
    }
}

When to Use Each

Use String When 📜

• Constants and literals
• Simple concatenations (1-2 operations)
• Immutable data requirements
• API parameters and return values
• Thread safety without performance concerns

// Good String usage
public static final String ERROR_MSG = "Error occurred";
String name = firstName + " " + lastName;
String filePath = directory + "/" + filename;

Use StringBuilder When ⚡

• Multiple concatenations
• Single-threaded environments
• Performance is critical
• Building large strings dynamically
• Most common choice for string building

// Good StringBuilder usage
StringBuilder sql = new StringBuilder();
sql.append("SELECT * FROM users WHERE ");
for (String condition : conditions) {
    sql.append(condition).append(" AND ");
}

Use StringBuffer When 🔒

• Multi-threaded string building
• Legacy code compatibility
• Thread safety is mandatory
• Concurrent access to shared string builder

// Good StringBuffer usage
public class LogBuffer {
    private StringBuffer buffer = new StringBuffer();

    public synchronized void addLog(String message) {
        buffer.append(new Date()).append(": ").append(message).append("\n");
    }

    public synchronized String getLogs() {
        return buffer.toString();
    }
}

Migration Guidelines

String → StringBuilder

// Before (inefficient)
String result = "";
for (String item : items) {
    result += item + ", ";
}

// After (efficient)
StringBuilder sb = new StringBuilder();
for (String item : items) {
    sb.append(item).append(", ");
}
String result = sb.toString();

StringBuffer → StringBuilder

// Before (thread-safe but slower)
StringBuffer buffer = new StringBuffer();
buffer.append("text");

// After (faster, manual sync if needed)
StringBuilder sb = new StringBuilder();
synchronized(lock) {
    sb.append("text");
}

Best Practices Summary

Conclusion

• String: Choose for simplicity and immutability requirements
• StringBuilder: Choose for performance in single-threaded scenarios (most common)
• StringBuffer: Choose only when thread safety is required

In modern Java development, StringBuilder is the go-to choice for string building operations, with StringBuffer reserved for specific multi-threading needs.