StringBuilder vs StringBuffer in Java

Direct Answer

StringBuilder and StringBuffer are mutable character-sequence builders with similar APIs. StringBuffer synchronizes its individual operations and can be shared for those operations; StringBuilder provides no synchronization and is the normal choice when the builder is confined to one thread. A multi-call check-then-act sequence is not atomic merely because it uses StringBuffer.

Code Example

public class BuilderDemo {
    public static void main(String[] args) {

        // StringBuilder — preferred for single-threaded code
        StringBuilder sb = new StringBuilder();
        sb.append("Java");
        sb.append(" is");
        sb.append(" fast");
        System.out.println(sb.toString()); // Java is fast

        // Chaining — append() returns 'this' so calls can be chained
        String result = new StringBuilder()
                .append("Hello")
                .append(", ")
                .append("World")
                .append("!")
                .toString();
        System.out.println(result); // Hello, World!

        // Other useful methods
        StringBuilder s = new StringBuilder("Hello World");
        s.insert(5, ",");          // Hello, World
        s.delete(0, 6);            // World
        s.reverse();               // dlroW
        System.out.println(s);     // dlroW
        System.out.println(s.length()); // 5

        // StringBuffer has Similar core API — just replace the class name
        // StringBuffer sbf = new StringBuffer();  -- thread-safe but slower
    }
}

Common Mistakes & Pitfalls

• Picking StringBuffer "to be safe" — its per-call lock is pure waste in single-threaded code, which is almost all string building. StringBuilder is the correct default, not the risky one.
• Believing synchronized methods make multi-step logic thread-safe — each call is atomic, but a check-then-append spanning two calls (if (sb.length() == 0) sb.append(x)) still races across threads. Thread safety of one method is not thread safety of your sequence.
• Sharing a local StringBuilder across threads when you don't need to — a builder created inside a method is already thread-confined; reaching for StringBuffer there adds lock overhead for nothing.
• Assuming they have different APIs — they don't. Every method matches, so switching between them is just changing the class name; there is nothing new to learn.