String物件是immutable不可變物件

StringBuffer和StringBuilder是可變的，為什麼，他們又是如何實現的？

這裡以StringBuilder為例，因為StringBuffer和StringBuilder大體是相同的，只是執行緒安全的差別以及由此產生的效率差別。

StringBuilder繼承了AbstractStringBuilder，並實現了Serializable和charSequance介面

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

我們建立一個StringBuilder物件，並執行append方法的時候，它會執行AbstractStringBuilder的append方法

StringBuilder sb= new StringBuilder();
sb.append("xxx");

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

下面是父類的append方法：在父類方法裡，它需要判斷是否擴容，具體在ensureCapacityInternal()方法裡

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

點進去，如果需要，則擴容，具體在expandCapacity方法裡

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

再點進去，我們會發現它預設擴容的大小是value.length*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);
    }

在這個方法的最後，有一行程式碼

value = Arrays.copyOf(value, newCapacity);

進入之後會發現，它重新建一個char型別陣列，因為同樣陣列大小定義了是不能再變的，只能新建

新建陣列後進行陣列複製，然後return這個新的陣列

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

最後再回到expandCapacity()方法，value指向新的char型別陣列（最後一行），實現字串擴充。

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

StringBuffer和StringBuilder相比，只是方法加了synchronized關鍵字修飾，因此是執行緒安全的。

但是效率要比後者低。

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