StringBuilder和StringBuffer源碼解析

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