java的可变类——StringBuffer

StringBuffer是一个线程安全的类。看这个类是否是线程安全的，就是看这个类提供的对成员变量进行操作的方法是否是同步的。

我们经常会拿StringBuffer和String进行比较，当我们进行字符串的拼接操作时，都会选择StringBuffer的append方法，之所以如此，就是认为，append方法拼接字符串的

效率会比较高。原因就是append方法是在原字符串的后面进行添加操作，不会像String一样，改变其值就是另外开辟一个空间。

 

通过证明，append的操作确实比“+”来的高效。

public static void main(String[]args) {
        String str="";
        long start0=System.currentTimeMillis();
        for(int i=0;i<10000;i++) {
            str+="feijishuo";
        }
        long end0=System.currentTimeMillis();
        System.out.println((end0-start0)+"ms");
        
        StringBuffer sb=new StringBuffer();
        long start1=System.currentTimeMillis();
        for(int i=0;i<10000;i++) {
            sb.append("feijishuo");
        }
        long end1=System.currentTimeMillis();
        System.out.println((end1-start1)+"ms");
}

563ms

1ms

当拼接的字符串越多时，这种差距越明显。

StringBuffer的属性类型为char[] value，是可变性参数，因此可以对其本身实例做修改后将这个实例返回。

细想一下，既然StringBuffer的底层是数组类型，而数组是固定长度的，要实现扩容只有新new出来一个数组，然后将其拷贝内容拷贝到这个

新数组，后又将append进来的字符拷贝到这个新数组的后面。

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

 public AbstractStringBuilder append(String str) {
        if (str == null) str = "null";
        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)
            expandCapacity(minimumCapacity);
  }

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

 public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
        if (srcBegin < 0) {
            throw new StringIndexOutOfBoundsException(srcBegin);
        }
        if (srcEnd > value.length) {
            throw new StringIndexOutOfBoundsException(srcEnd);
        }
        if (srcBegin > srcEnd) {
            throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
        }
        System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
    }

代码分析：

StringBuffer如果不需要进行扩容，就会直接将append进来的字符，放到数组后面；如果需要进行扩容，就会新生成一个大空间的数组。但是依旧返回的是同一个实例。