这三个类是平时开发中经常遇到的，主要差别是运行速度和线程安全，使用起来String最方便了，另外两个稍微复杂一些。
从运行速度角度看，StringBuilder>StringBuffer>String。
从线程安全角度看，StringBuffer是线程安全的，StringBuilder和String不是。
下面从代码的角度分析一下，示例代码：
StringBuilder strBuilder = new StringBuilder();
strBuilder.append(100);
strBuilder.append("123"); StringBuffer strBuffer = new StringBuffer();
strBuffer.append(100);
strBuffer.append("123"); String strTest = "start";
strTest += 100;
strTest += "123";
首选看下StringBuilder的实现：
public StringBuilder append(int i) {
super.append(i);
return this;
}
public AbstractStringBuilder append(int i) {
if (i == Integer.MIN_VALUE) { // 是否是最小值
append("-2147483648");
return this;
}
// 计算i的字符串长度，判断是否需要增大存储空间
int appendedLength = (i < 0) ? Integer.stringSize(-i) + 1
: Integer.stringSize(i);
int spaceNeeded = count + appendedLength;
ensureCapacityInternal(spaceNeeded);
Integer.getChars(i, spaceNeeded, value); // 使用Integer的getChars方法，计算i的字符串值并把值拷贝到value中
count = spaceNeeded;
return this;
}
// 其中扩展空间时，会按照现有空间的2倍+2来扩展，保证不需要一直来扩展，提高效率void expandCapacity(int minimumCapacity) {
int newCapacity = value.length * 2 + 2;
if (newCapacity - minimumCapacity < 0)
newCapacity = minimumCapacity;
if (newCapacity < 0) {
if (minimumCapacity < 0) // overflow
throw new OutOfMemoryError();
newCapacity = Integer.MAX_VALUE;
}
// 计算好扩展大小后，重新申请存储空间并把旧值拷贝到新的存储空间
value = Arrays.copyOf(value, newCapacity);
}
//Arrays.copyOf的实现public static char[] copyOf(char[] original, int newLength) {
char[] copy = new char[newLength]; // 新申请空间，并拷贝
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
} public StringBuilder append(String str) {
super.append(str);
return this;
}
public AbstractStringBuilder append(String str) {
if (str == null) str = "null";
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count); // 使用了String的getChars方法把str拷贝到value中去
count += len;
return this;
}
str.getChars代码：
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) {
throw new StringIndexOutOfBoundsException(srcBegin);
}
if (srcEnd > value.length) {
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) {
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
// 最终使用 System.arraycopy完成字符串的拷贝
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}再看下StringBuffer的实现：
public synchronized StringBuffer append(int i) { // 多了同步关键字，是线程安全的
super.append(i); // 调用了AbstractStringBuilder的append方法，和StringBuilder使用的是一样的方法
return this;
} public synchronized StringBuffer append(String str) { // 使用了同步关键字
super.append(str); // 使用了AbstractStringBuilder的方法
return this;
}从上面分析可以看到，StringBuffer和StringBuilder是继承了相同的父类AbstractStringBuilder，然后通过在方法上使用了同步关键字实现了线程安全，看下类定义：
public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{} public final class StringBuffer
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{}
最后再看下String的操作，jvm会申请一段新的char数组，并把"start"和"100"顺序拷贝进去，第二次再申请一段新的char数组，并把"start100"和"123"顺序拷贝进去。
由于String的每次拷贝都会有申请新的存储空间和拷贝动作，而StringBuffer和StringBuilder只有在空间不够用的时候才会申请新的存储空间，因此从效率上讲String是最慢的。
综上所述，对String，StringBuilder和StringBuffer的使用做个小结：
1. String 适用次数较少的拷贝场景。
2. StringBuilder适用无线程安全要求的大量拷贝场景。
2. StringBuffer适用要求线程安全的大量拷贝场景。