StringBuffer、StringBuilder源码分析

环境：JDK8

类定义

StringBuffer：

  
  
  
  

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

StringBuilder：

  
  
  
  

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

可以看出两个类都是无法被继承的，因为都被final修饰。实现的接口一样，并且继承的抽象类也一样都是AbstractStringBuilder。

构造函数

StringBuffer：

  
  
  
  

   
   
   
   
 public StringBuffer() {
   
   
   
   
        super(16);
   
   
   
   
}
  
  
  
  

该构造函数传入整数参数16调用父类方法：

  
  
  
  

   
   
   
   
AbstractStringBuilder(int capacity) {
   
   
   
   
        value = new char[capacity];
   
   
   
   
    }
  
  
  
  

可以看到，构造了一个容量为16的字符数组，由此可知，StringBuffer底层实现和String一样也是字符数组。

如果想指定容量构造StringBuffer，可用StringBuffer(int capacity)方法，这点看源码：

  
  
  
  

   
   
   
   
 public StringBuffer(int capacity) {
   
   
   
   
        super(capacity);
   
   
   
   
    }
  
  
  
  

该方法也会调用父类的构造函数构造一个指定容量的字符数组。

这点StringBuilder和StringBuffer源码完全一样，就不贴代码了。

再来看另个构造函数StringBuffer(String str)：

  
  
  
  

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

第一句上面提到了，不再说明。直接看append(String str)方法源码：

  
  
  
  

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

可以看到StringBuffer的append方法是同步的，由于被synchronized修饰。

看toStringCache定义：

  
  
  
  

   
   
   
   
private transient char[] toStringCache;
  
  
  
  

可以看到toStringCahe是被transient关键字修饰的字符数组。它主要用来缓存被toString方法返回的最后被修改过的值，StringBuffer每次被修改，它都会改变，因此它是瞬态的。

Append

接下来调用父类的append方法：

  
  
  
  

   
   
   
   
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;
   
   
   
   
    }
  
  
  
  

首先判断字符串是否为空，是则添加一个空字符串并且容量加4,这点可看appendNull源码实现。接下来，字符串不为空，则扩容加上字符串长度，然后调用该字符串的getChars方法将源字符数组str复制到目标数组value，实现字符串的拼接，这点通过查看getChars方法源码可知。

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);
   
   
   
   
    }
  
  
  
  

接下来将字符的数量count加上字符串的长度len，最后返回当前对象的引用。

对比StringBuilder的append(String str)方法:

  
  
  
  

   
   
   
   
@Override
   
   
   
   
    public StringBuilder append(String str) {
   
   
   
   
        super.append(str);
   
   
   
   
        return this;
   
   
   
   
    }
  
  
  
  

可以看到StringBuilder的append方法不是同步的，其他的语句和StringBuffer一样。

StringBuffer的append重载方法列表：

  
  
  
  

   
   
   
   
public synchronized StringBuffer append(Object obj);
   
   
   
   
public synchronized StringBuffer append(String str);
   
   
   
   
public synchronized StringBuffer append(StringBuffer sb);
   
   
   
   
synchronized StringBuffer append(AbstractStringBuilder asb);（这个方法是1.8开始添加的）。
   
   
   
   
public synchronized StringBuffer append(CharSequence s);
   
   
   
   
public synchronized StringBuffer append(char[] str);
   
   
   
   
public synchronized StringBuffer append(char[] str, int offset, int len);
   
   
   
   
public synchronized StringBuffer append(boolean b);
   
   
   
   
public synchronized StringBuffer append(char c);
   
   
   
   
public synchronized StringBuffer append(int i) ;
   
   
   
   
public synchronized StringBuffer append(long lng);
   
   
   
   
public synchronized StringBuffer append(float f);
   
   
   
   
public synchronized StringBuffer append(double d);
   
   
   
   
public synchronized StringBuffer append(CharSequence s, int start, int end);
  
  
  
  

以上重载方法源码在本类中的逻辑完全和append(String str)方法一样，都是调用父类的具体实现。

StringBuilder的append重载方法列表和StringBuffer的是同样的，但都是非同步的。

经过以上分析我们知道StringBuffer和StringBuilder的大多数方法都是调用父类的具体实现，只是StringBuffer的方法被synchronized修饰，当然不是全部都被synchronized修饰，而Stringbuilder的方法则一定没有被修饰。

因此可以得出结论：StringBuffer是同步的，可以用在多线程环境中，而StringBuilder则不能。

delete

接下来将分析StringBuffer和StringBuilder的共同调用父类AbstractStringBuilder的delete方法源码：

  
  
  
  

   
   
   
   
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;
   
   
   
   
    }
  
  
  
  

参数start，开始索引，包含。参数end，结束索引，不包含。

首先判断边界，可以看到end如果比字符的数量大，则end会被赋值为该字符数组的长度。

然后计算索引的差值是否大于0,及索引有效，若是则将字符数组value从start+len开始复制到start开始处并且复制长度为count-end，即删除从start开始到end为止的字符，并重新拼接拷贝，最后字符数量减去len。

delete方法的逻辑和append方法完全一样。

replace

接下来将分析StringBuffer和StringBuilder的共同调用父类AbstractStringBuilder的replace方法源码：

  
  
  
  

   
   
   
   
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;
   
   
   
   
    }
  
  
  
  

参数start，开始索引，包含。参数end，结束索引，不包含。

首先判断边界，计算字符串长度及字符数量，然后根据字符数量判断是否需要增加字符数组容量，这点可看ensureCapacityInternal方法源码，得知在该方法中会判断当前传递过去的字符数量newCount是否会比原本字符数组value长度大，若是则扩大容量，否则什么都不做，即替换后字符数组不会溢出：

   
   
   
   

    
    
    
    
 private void ensureCapacityInternal(int minimumCapacity) {
    
    
    
    
        // overflow-conscious code
    
    
    
    
        if (minimumCapacity - value.length > 0)
    
    
    
    
            expandCapacity(minimumCapacity);
    
    
    
    
    }
   
   
   
   

expandCapacity方法源码：

   
   
   
   

    
    
    
    
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);
    
    
    
    
    }
   
   
   
   

可以看到新的字符数组容量会扩大到原始容量的2倍再加上2。

最后调用Arrays的静态方法copyOf通过填充null或删除字符来扩大或减少字符数组的容量。

再回到replace(int start, int end, String str)方法，继续往下的代码逻辑就是字符数组value的拷贝，第一次拷贝从end开始，长度为count - end，拷贝到目标字符数组的索引从start + len开始。即拷贝不需要替换的字符到扩容或缩容后的字符数组的新位置。

第二次拷贝，将第一步拷贝后的字符数组作为参数调用str.getChars(value, start)方法，该方法内部是从0开始拷贝，长度为str字符串的长度，拷贝到目标字符数组的索引从start开始。即拷贝字符串str到value字符数组替换原本的字符。

最后将字符数量赋值为新的值，即替换后字符串的长度。

我们注意到以上两个方法都不是同步的，所以对于多线程环境下字符串的替换操作也推荐使用StringBuffer来实现。

insert

下面来看下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;
    
    
    
    
    }
   
   
   
   

可以看到首先开始是边界判断，从第6行开始往后的逻辑就和replate方法一样了，都要进行两次字符数组的拷贝。相关方法源码上面已讲解过，不再深入。

indexOf

indexOf方法实际是调用String类的静态方法tatic int indexOf(char[] source, int sourceOffset, int sourceCount,
       char[] target, int targetOffset, int targetCount, int fromIndex)，具体分析看这篇

http://blog.csdn.net/u011726984/article/details/51326697#t6 

indexOf(String)方法返回的是子串首次出现在字符串中的位置索引，而lastIndexOf（String）方法返回的是子串最后一次出现在字符串中的位置索引。

   
   
   
   

    
    
    
    
StringBuffer stringBuffer = new StringBuffer("abcdc");
    
    
    
    
int i = stringBuffer.indexOf("c");
    
    
    
    
int j = stringBuffer.lastIndexOf("c");
    
    
    
    
System.out.print("i="+i + "\tj=" + j);
   
   
   
   

结果为：

   
   
   
   

    
    
    
    
i=2 j=4
   
   
   
   

若搜索的字符串为“cd”则都返回2。

indexOf（String, int)返回的是字串从指定位置开始搜索首次出现在字符串中的位置索引，而lastIndexOf（String, int)返回的是字串从指定位置为结束位置开始搜索最后一次出现在字符串中的位置索引。

   
   
   
   

    
    
    
    
StringBuffer stringBuffer = new StringBuffer("abcdc");
    
    
    
    
int i = stringBuffer.indexOf("cd", 3);
    
    
    
    
int j = stringBuffer.lastIndexOf("cd", 3);
    
    
    
    
 System.out.print("i="+i + "\tj=" + j);
   
   
   
   

结果为：

    
    
    
    

     
     
     
     
i=-1 j=2
    
    
    
    

这里第3句，应该从索引3开始查找，j值应该返回-1才对，可是结果却返回2。

将第2行参数值改为1，即从索引1开始搜索，结果为：

    
    
    
    

     
     
     
     
i=2 j=2
    
    
    
    

将第2、3行参数都改为1,结果：

    
    
    
    

     
     
     
     
i=2 j=-1
    
    
    
    

以上结果本人有点费解，查看indexOf和lastIndexOf的源码说明，第二个参数应该是开始搜索的索引的位置，可是结果却和源码说明矛盾。

subSequence&substring

subSequence方法返回调用的是substring：

   
   
   
   

    
    
    
    
public CharSequence subSequence(int start, int end) {
    
    
    
    
        return substring(start, end);
    
    
    
    
    }
   
   
   
   

关于substring方法源码分析查看http://blog.csdn.net/u011726984/article/details/51326697#t5 

toString

先看StringBuffer的toString方法源码：

   
   
   
   

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

对比Stringbuilder的toString方法源码：

   
   
   
   

    
    
    
    
public String toString() {
    
    
    
    
 // Create a copy, don't share the array
    
    
    
    
 return new String(value, 0, count);
    
    
    
    
 }
   
   
   
   

通过对比可以看出StringBuffer的toString方法返回的是“共享数组”，而StringBuilder返回的是普通数组。

具体原因查看此文http://blog.csdn.net/u011726984/article/details/51326697 的concat方法源码的讲解，其中有提到。

如有疏漏请指出，谢谢！