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适用要求线程安全的大量拷贝场景。