StringBuilder源码学习笔记

朱雀 2022-05-30 00:56 260阅读 0赞

1、public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence 2、几个构造函数 默认构造函数创建一个长度为16的StringBuilder，调用父类的构造函数，父类AbstractStringBuilder维护了char[] value，int count。如果以String或者CharSequence对象作为参数，会创建长度为str.length() + 16的StringBuilder。 AbstractStringBuilder(int capacity) { 
            value = new char[capacity];
    }
    
    public StringBuilder() {
        super(16);
    }
    
    public StringBuilder(int capacity) {
        super(capacity);
    }
    
    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }
    
    public StringBuilder(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }
    
    3、append方法，调用父类的append方法，如果参数的str是null，会直接append一个null字符串。内置许多重载的append方法。
    @Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj)); 
    }
    @Override
    public StringBuilder append(String str) {
        super.append(str); 
        return this;
    }
    
    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 void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    
    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;
    }
    
    4、StringBuilder扩容。扩容时会先生成一个newCapacity，为value.length*2+2，若其小于minCapacity，则直接扩容至minCapacity。一般情况下，newCapacity就是扩容之后的StringBuilder大小。
    private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity): newCapacity;
        }
    
    private int hugeCapacity(int minCapacity) {
        if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
            throw new OutOfMemoryError();
        }
        return (minCapacity > MAX_ARRAY_SIZE)? minCapacity : MAX_ARRAY_SIZE;
    }
    
    5、delete方法。append和delete方法底层都是调用System.arraycopy方法。
    @Override
    public StringBuilder delete(int start, int end) {
        super.delete(start, end);
        return this;
    }
    
    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;
    }
    
    @Override
    public StringBuilder deleteCharAt(int index) {
        super.deleteCharAt(index);
        return this;
    }
    
    public AbstractStringBuilder deleteCharAt(int index) {
        if ((index < 0) || (index >= count))
            throw new StringIndexOutOfBoundsException(index);
        System.arraycopy(value, index+1, value, index, count-index-1);
        count--;
        return this;
    }
    
    6、insert方法。
    @Override
    public StringBuilder insert(int offset, String str) {
        super.insert(offset,  str);
        return this;
    }
    
    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;
    }
    
    public static native void arraycopy(Object src,  int  srcPos,
                                            Object dest, int destPos,
                                            int length);
    
    7、toString方法，直接生成一个新的String对象。第二个是StringBuffer的toString方法，有一个String类型的toStringCache变量缓存了toString的内容。
    @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }
    
    @Override
    public synchronized String toString() {
        if (toStringCache == null) {
            toStringCache = Arrays.copyOfRange(value, 0, count);
        }
        return new String(toStringCache, true);
    }
    
    8、序列化方法。
    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        s.defaultWriteObject();
        s.writeInt(count);
        s.writeObject(value);
    }
    
    private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        count = s.readInt();
        value = (char[]) s.readObject();
    }