前言

我们知道，对于一般大量频繁的String操作，我们不建议也不应该直接用String进行相加操作，而我们应借助StringBuffer或者StringBuilder来实现。

StringBuffer是线程安全的，而StringBuilder是线程不安全的。

由此看来，StringBuilder对String的操作快，不安全，适合单线程；StringBuilder对String的操作较StringBuilder慢，安全，适合多线程和单线程。

我们今天分析一下二者的源码。

分析

class定义

两者的class定义。

//StringBuffer
 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{}

//StringBuilder
public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{}

二者的UML图如下：

可以看到二者均继承AbstractStringBuilder类，且都实现了Serializable和CharSequence接口。即二者分别是AbstractStringBuilder类的安全和不安全的一种实现。

构造器

我们先来分析下StringBuffer。

public StringBuffer() {
    super(16);
}
public StringBuffer(int capacity) {
    super(capacity);
}
public StringBuffer(String str) {
    super(str.length() + 16);
    append(str);
}

可以看到，当我们new StringBuffer时，如果什么也不传，默认赋予16数组长度，如果传入一个String，则长度为String.length()+16。

append方法

在看一下append方法。关键字synchronized 对该方法进行了加锁，保证安全，toStringCache 赋值为空。然后调用AbstractStringBuilder的append方法。

StringBuffer append方法。

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

AbstractStringBuilder里的方法。

public AbstractStringBuilder append(String str) {
    if (str == null)
        return appendNull();
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}
private AbstractStringBuilder appendNull() {
    int c = count;
    ensureCapacityInternal(c + 4);
    final char[] value = this.value;
    value[c++] = 'n';
    value[c++] = 'u';
    value[c++] = 'l';
    value[c++] = 'l';
    count = c;
    return this;
}
private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0) {
        value = Arrays.copyOf(value,
                newCapacity(minimumCapacity));
    }
}

String里的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(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}

对于这段代码的理解。追加一个Str时，如果是null，则调用appendNull方法，在后面直接加一个null字符串。如果不为空，拿到字符串长度，进行容量扩容为当前容量+str的长度，调用String的getChars方法，将字符串数组加在后面，这最后是个char数组。

通过上图可以看到 AbstractStringBuilder是基于char数组实现的，count用于统计当前长度。

toString方法

我们看一下toString方法。可以发现他把字符串数组先放到了缓存数组，然后在返回一个String。当StringBuffer变化时，如append，则直接把toStringCache 赋值为空。

@Override
public synchronized String toString() {
    if (toStringCache == null) {
        toStringCache = Arrays.copyOfRange(value, 0, count);
    }
    return new String(toStringCache, true);
}

insert方法

我们再来分析一下StringBuffer的insert，由于重载方法较多，我们只分析insert String的代码。

StringBuffer insert方法。

@Override
public synchronized StringBuffer insert(int offset, String str) {
    toStringCache = null;
    super.insert(offset, str);
    return this;
}

AbstractStringBuilder里的insert方法。

public AbstractStringBuilder insert(int offset, String str) {
    if ((offset < 0) || (offset > length()))
        throw new StringIndexOutOfBoundsException(offset);
    if (str == null)
        str = "null";
    int len = str.length();
    ensureCapacityInternal(count + len);
    System.arraycopy(value, offset, value, offset + len, count - offset);
    str.getChars(value, offset);
    count += len;
    return this;
}

可以看到与append大致相同，就是调用System.arraycopy的时候插入的位置发生了变化。

其他方法（delete，replace等）

//StringBuffer
   @Override
   public synchronized StringBuffer delete(int start, int end) {
       toStringCache = null;
       super.delete(start, end);
       return this;
   }
   //AbstractStringBuilder
   public AbstractStringBuilder delete(int start, int end) {
       if (start < 0)
           throw new StringIndexOutOfBoundsException(start);
       if (end > count)
           end = count;
       if (start > end)
           throw new StringIndexOutOfBoundsException();
       int len = end - start;
       if (len > 0) {
           System.arraycopy(value, start+len, value, start, count-end);
           count -= len;
       }
       return this;
   }
   
   //StringBuffer
   @Override
   public synchronized StringBuffer replace(int start, int end, String str) {
       toStringCache = null;
       super.replace(start, end, str);
       return this;
   }
   //AbstractStringBuilder
   public AbstractStringBuilder replace(int start, int end, String str) {
       if (start < 0)
           throw new StringIndexOutOfBoundsException(start);
       if (start > count)
           throw new StringIndexOutOfBoundsException("start > length()");
       if (start > end)
           throw new StringIndexOutOfBoundsException("start > end");

       if (end > count)
           end = count;
       int len = str.length();
       int newCount = count + len - (end - start);
       ensureCapacityInternal(newCount);

       System.arraycopy(value, end, value, start + len, count - end);
       str.getChars(value, start);
       count = newCount;
       return this;
   }

可以看到他们均使用了System.arraycopy方法。这儿不再一一赘述。

其他

我们再看一下StringBuilder的源码。发现它与StringBuffer差别很小。

不同点：

增删改操作上没有synchronized关键字。
没有private transient char[] toStringCache;的定义。

第一点正好验证了StringBuilder不是线程安全的，第二点StringBuffer中toStringCache的引入是为了在多线程并发下读取写入数据起到一定的缓存缓冲作用。

结论

我们可以看到，无论StringBuilder还是StringBuffer，都是AbstractStringBuilder的实现类。

AbstractStringBuilder对字符串的操作，实质是将它存储在一个char数组中，这样减小了内存开销。我们知道，如果使用String连加，会创造大量String对象，GC来不及回收，导致OOM异常或内存开销增大。StringBuffer和StringBuilder对String的操作完美的解决了这个问题，且相当于提供了操作字符串更加直观的方法（如insert，delete，append等）。这是值得我们借鉴和学习的。

以上就是StringBuffer和StringBuilder的源码分析。