String,StringBuilder和StringBuffer的特点和使用场景

这三个类是平时开发中经常遇到的，主要差别是运行速度和线程安全，使用起来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适用要求线程安全的大量拷贝场景。