StringBuilder和StringBuffer

StringBuilder

StringBuilder是可變字符串類型，它被人所熟知的功能就是能夠很方便的對字符串進行拼接、構造：

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

方法是 final的，繼承了 AbstractStringBuilder抽象類：

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    char[] value;
    int count;
    ...
}

能夠看到它實現了 Appendable接口，而 Appendable接口就是提供了能夠被添加char序列和值的功能，它實現了三種 append方法：

Appendable append(CharSequence csq) throws IOException;
Appendable append(CharSequence csq, int start, int end) throws IOException;
Appendable append(char c) throws IOException;

其中 CharSequence是 char值的可讀序列，此接口對許多不一樣種類的 char 序列提供統一的只讀訪問， String StringBuilder StringBuffer都實現了這個接口：

int length();
char charAt(int index);
CharSequence subSequence(int start, int end);

在 AbstractStringBuilder抽象類中，提供了一系列的 append和 insert方法的實現，下面是其中一種實現：

public AbstractStringBuilder append(String str) {
        if (str == null) str = "null"; //若是爲空，則添加null字符串
        int len = str.length();
        ensureCapacityInternal(count + len);//保證容量
        //複製str字符串到char數組value，從count位開始添加
        str.getChars(0, len, value, count);
        count += len;
        return this;
    }

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

若是傳遞的最小容量大於現有容量，則必須進行擴容：

void expandCapacity(int minimumCapacity) {
        //新容量爲old*2+2
        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);
    }

注意： 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;
    }

StringBuffer

StringBuffer類的出現實際上比 StringBuilder要早，當初提供 StringBuilder類只是爲了提供一個單個線程使用的 StringBuffer等價類。若是觀察 StringBuffer的源代碼，能夠發現它的方法和 StringBuilder相同，只不過都加上了 synchronized ，好比：

public synchronized StringBuffer append(String str) {
        super.append(str);
        return this;
    }

StringBuilder vs StringBuffer

1. 如今咱們已經明確的記住了 StringBuffer是線程安全的，而 StringBuilder不是

2. 在效率上， StringBuffer由於對方法作了同步，因此通常是低於 StringBuilder的

3. 兩者都是可變的，由於兩者都繼承 AbstractStringBuilder，它的 char[] value 沒有使用 final修飾，只是普通數組。 String的 value是 final的,即不可變的

4. 都有實現 CharSequence接口