StringBuffer用于存储将要更改的字符串（字符串对象不能更改）。它会根据需要自动展开。相关类：String、CharSequence。

StringBuilder是在Java5中添加的。它在所有方面都与StringBuffer相同，只是它不同步，这意味着如果多个线程同时访问它，可能会出现问题。对于单线程程序，最常见的情况是，避免同步开销会使StringBuilder稍微快一些。

首先让我们看看相似之处：StringBuilder和StringBuffer都是可变的。这意味着您可以在同一位置更改它们的内容。

差异：StringBuffer也是可变的和同步的。其中，作为StringBuilder是可变的，但默认情况下不同步。

同步（synchronization）的含义：当某些东西被同步时，多个线程可以访问并修改它，而不会产生任何问题或副作用。StringBuffer是同步的，因此您可以在多个线程中使用它，而不会出现任何问题。

何时使用哪一个？StringBuilder：当您需要一个可以修改的字符串，并且只有一个线程在访问和修改它时。StringBuffer：当您需要一个可以修改的字符串，并且多个线程正在访问和修改它时。

注意：不要不必要地使用StringBuffer，也就是说，如果只有一个线程在修改和访问它，就不要使用它，因为它有很多用于同步的锁定和解锁代码，这将不必要地占用CPU时间。除非需要，否则不要使用锁。

但需要借助一个例子来明确区别吗？StringBuffer或StringBuilder

只需使用StringBuilder，除非您确实试图在线程之间共享缓冲区。StringBuilder是原始同步StringBuffer类的非同步（开销更少=效率更高）弟弟。

StringBuffer排名第一。Sun关注所有条件下的正确性，因此他们使其同步，以使其线程安全，以防万一。

StringBuilder后来出现了。StringBuffer的大多数使用都是单线程的，不必要地支付了同步的成本。

由于StringBuilder是没有同步的StringBuffer的替代品，因此任何示例之间都不会有差异。

如果您试图在线程之间共享，可以使用StringBuffer，但要考虑是否需要更高级别的同步，例如，如果您同步使用StringBuilder的方法，可能不需要使用StringBuffer。

一个简单的程序说明了StringBuffer和StringBuilder之间的区别：

/**
 * Run this program a couple of times. We see that the StringBuilder does not
 * give us reliable results because its methods are not thread-safe as compared
 * to StringBuffer.
 * 
 * For example, the single append in StringBuffer is thread-safe, i.e.
 * only one thread can call append() at any time and would finish writing
 * back to memory one at a time. In contrast, the append() in the StringBuilder 
 * class can be called concurrently by many threads, so the final size of the 
 * StringBuilder is sometimes less than expected.
 * 
 */
public class StringBufferVSStringBuilder {

    public static void main(String[] args) throws InterruptedException {

        int n = 10; 

        //*************************String Builder Test*******************************//
        StringBuilder sb = new StringBuilder();
        StringBuilderTest[] builderThreads = new StringBuilderTest[n];
        for (int i = 0; i < n; i++) {
            builderThreads[i] = new StringBuilderTest(sb);
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].join();
        }
        System.out.println("StringBuilderTest: Expected result is 1000; got " + sb.length());

        //*************************String Buffer Test*******************************//

        StringBuffer sb2 = new StringBuffer();
        StringBufferTest[] bufferThreads = new StringBufferTest[n];
        for (int i = 0; i < n; i++) {
            bufferThreads[i] = new StringBufferTest(sb2);
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].join();
        }
        System.out.println("StringBufferTest: Expected result is 1000; got " + sb2.length());

    }

}

// Every run would attempt to append 100 "A"s to the StringBuilder.
class StringBuilderTest extends Thread {

    StringBuilder sb;

    public StringBuilderTest (StringBuilder sb) {
        this.sb = sb;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb.append("A");
        }

    }
}


//Every run would attempt to append 100 "A"s to the StringBuffer.
class StringBufferTest extends Thread {

    StringBuffer sb2;

    public StringBufferTest (StringBuffer sb2) {
        this.sb2 = sb2;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb2.append("A");
        }

    }
}

StringBuffer中的每个方法都是同步的。因此，一次只允许一个线程操作StringBuffer对象。它增加了线程的等待时间并造成性能问题为了解决这个问题，SUN People推出了1.5版本的StringBuilder。

其他人正确地指出了两者之间的关键区别。然而，在性能方面，我想补充一点，JVM级别的优化“锁定Elision”可以使同步上下文中的性能差异几乎不存在。关于这一点的精彩阅读在这里和这里