Java常用类: StringBuffer与StringBuilder的区别

作为一个稀有的Java妹子，所写的所有博客都只是当作自己的笔记，留下证据自己之前是有用心学习的～哈哈哈哈（如果有不对的地方，也请大家指出，不要悄悄咪咪的不告诉我）

StringBuffer与StringBuilder

1.StringBuffer和StringBuilder都继承AbstractStringBuilder。
2.StringBuffer和StringBuilder的value[]没有被final修饰，所以是可变字符串，通过自动扩容机制来改变字符串。
3.StringBuffer类的每个方法基本上都使用了synchronized关键字，所以是线程安全的，但是因为线程创建与销毁的开销，处理速度较慢；StringBuilder类的方法没有用synchronized，是线程不安全的，相反处理速度快。

1.继承关系分析

public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence
abstract class AbstractStringBuilder implements Appendable, CharSequence {
   	//没有被final修饰
    char[] value;
    int count;
    ...省略其他
}

2.扩容分析

初始化容量是16，执行append的时候会调用ensureCapacityInternal方法判断当前容量是否够，不够的话扩大为当前容量的2倍+2，调用Arrays.copyOf(value,newCapacity(minimumCapacity))完成扩容

	//初始长度是16
 	public StringBuffer() {
        super(16);
    }
    //创建时也可自己指定长度
    public StringBuffer(int capacity) {
        super(capacity);
    }
    public StringBuffer(String str) {
        super(str.length() + 16);
        append(str);
    }
	//执行append的时候会调用ensureCapacityInternal方法判断当前容量是否够，不够的话扩大为当前容量的2倍+2
	@Override
    public AbstractStringBuilder append(CharSequence s, int start, int end) {
        if (s == null)
            s = "null";
        if ((start < 0) || (start > end) || (end > s.length()))
            throw new IndexOutOfBoundsException(
                "start " + start + ", end " + end + ", s.length() "
                + s.length());
        int len = end - start;
        ensureCapacityInternal(count + len);
        for (int i = start, j = count; i < end; i++, j++)
            value[j] = s.charAt(i);
        count += len;
        return this;
    }
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }
    private int newCapacity(int minCapacity) {
        // 扩展容量为2*原数组长度+2
        int newCapacity = (value.length << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }

3.线程安全分析

StringBuffer:基本上所有的方法都被synchronized关键字修饰，线程安全

public synchronized StringBuffer append(CharSequence s) {
        toStringCache = null;
        super.append(s);
        return this;
    }
public synchronized StringBuffer replace(int start, int end, String str) {
        toStringCache = null;
        super.replace(start, end, str);
        return this;
    }
public synchronized String substring(int start, int end) {
        return super.substring(start, end);
    }

StringBuilder：都没有synchronized关键字修饰，线程不安全

public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));
    }
 public int indexOf(String str) {
        return super.indexOf(str);
    }