Java-StringBuffer

声明

1）该文章整理自网上的大牛和专家无私奉献的资料，具体引用的资料请看参考文献。
2）本文仅供学术交流，非商用。如果某部分不小心侵犯了大家的利益，还望海涵，并联系博主删除。
3）博主才疏学浅，文中如有不当之处，请各位指出，共同进步，谢谢。
4）此属于第一版本，若有错误，还需继续修正与增删。还望大家多多指点。大家都共享一点点，一起为祖国科研的推进添砖加瓦。

前言

StringBuffer类表示一个可变的字符序列。StringBuffer的API与StringBuilder互相兼容，但是StringBuffer是线程安全的。在可能的情况下，建议优先使用StringBuilder，因为在大多数实现中它比StringBuffer更快。

源码分析

定义

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
{
    ...
}

StringBuffer类被 final 所修饰，因此不能被继承。

StringBuffer类继承于 AbstractStringBuilder类。实际上，AbstractStringBuilder类具体实现了可变字符序列的一系列操作，比如：append()、insert()、delete()、replace()、charAt()方法等。值得一提的是，StringBuilder也是继承于AbstractStringBuilder类。

StringBuffer类实现了2个接口：

1. Serializable 序列化接口，表示对象可以被序列化。
2. CharSequence 字符序列接口，提供了几个对字符序列进行只读访问的方法，比如：length()、charAt()、subSequence()、toString()方法等。

主要变量

private transient char[] toStringCache;

// AbstractStringBuilder.java
char[] value;

int count;

value、count这两个变量是定义在AbstractStringBuilder类中的。其中：

1. toStringCache 用来缓存toString()方法返回的最近一次的value数组中的字符。当修改StringBuffer对象时会被清除。
2. value 用来存储字符序列中的字符。value是一个动态的数组，当存储容量不足时，会对它进行扩容。
3. count 表示value数组中已存储的字符数。

构造方法

public StringBuffer() {
    super(16);
}

public StringBuffer(int capacity) {
    super(capacity);
}

public StringBuffer(String str) {
    super(str.length() + 16);
    append(str);
}

public StringBuffer(CharSequence seq) {
    this(seq.length() + 16);
    append(seq);
}

// AbstractStringBuilder.java
AbstractStringBuilder(int capacity) {
    value = new char[capacity];
}

StringBuffer类提供了4个构造方法。构造方法主要完成了对value数组的初始化。其中：

1. 默认构造方法设置了value数组的初始容量为16。
2. 第2个构造方法设置了value数组的初始容量为指定的大小。
3. 第3个构造方法接受一个String对象作为参数，设置了value数组的初始容量为String对象的长度+16，并把String对象中的字符添加到value数组中。
4. 第4个构造方法接受一个CharSequence对象作为参数，设置了value数组的初始容量为CharSequence对象的长度+16，并把CharSequence对象中的字符添加到value数组中。

append()方法

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

// AbstractStringBuilder.java
public AbstractStringBuilder append(boolean b) {
    if (b) {
        ensureCapacityInternal(count + 4);
        value[count++] = 't';
        value[count++] = 'r';
        value[count++] = 'u';
        value[count++] = 'e';
    } else {
        ensureCapacityInternal(count + 5);
        value[count++] = 'f';
        value[count++] = 'a';
        value[count++] = 'l';
        value[count++] = 's';
        value[count++] = 'e';
    }
    return this;
}    

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

// AbstractStringBuilder.java
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;
}    

append()方法将指定参数类型的字符串表示形式追加到字符序列的末尾。StringBuffer类提供了一系列的append()方法，它可以接受AbstractStringBuilder、boolean、char、char[]、CharSequence、double、float、int、long、Object、String、StringBuffer这些类型的参数。这些方法最终都调用了父类AbstractStringBuilder类中对应的方法。最后，append()方法返回了StringBuffer对象自身，以便用户可以链式调用StringBuffer类中的方法。

AbstractStringBuilder类的各个append()方法大同小异。append()方法在追加字符到value数组中之前都会调用ensureCapacityInternal()方法来确保value数组有足够的容量，然后才把字符追加到value数组中。

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

// Arrays.java
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;
}

ensureCapacityInternal()方法判断value数组的容量是否足够，如果不够，那么调用expandCapacity()方法进行扩容。

expandCapacity()方法默认情况下将数组容量扩大到原数组容量的2倍+2。数组的容量最大只能扩容到Integer.MAX_VALUE。最后，调用Arrays类的copyOf()静态方法来创建一个新数组和拷贝原数据到新数组，并将value指向新数组。

@Override
public synchronized StringBuffer delete(int start, int end) {
    toStringCache = null;
    super.delete(start, end);
    return this;
}

// AbstractStringBuilder.java
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;
}    

delete()方法删除指定位置的字符。删除的字符从指定的start位置开始，直到end-1位置。delete()方法也调用了父类AbstractStringBuilder类中对应的方法。

delete()方法首先检查参数的合法性。当end大于value数组中已存储的字符数count时，end取count值。最后，当需要删除的字符数大于1的时候，调用System类的arraycopy()静态方法进行数组拷贝完成删除字符的操作，并更新count的值。

replace()方法

@Override
public synchronized StringBuffer replace(int start, int end, String str) {
    toStringCache = null;
    super.replace(start, end, str);
    return this;
}

// AbstractStringBuilder.java
public AbstractStringBuilder replace(int start, int end, String str) {
    if (start < 0)
        throw new StringIndexOutOfBoundsException(start);
    if (start > count)
        throw new StringIndexOutOfBoundsException("start > length()");
    if (start > end)
        throw new StringIndexOutOfBoundsException("start > end");

    if (end > count)
        end = count;
    int len = str.length();
    int newCount = count + len - (end - start);
    ensureCapacityInternal(newCount);

    System.arraycopy(value, end, value, start + len, count - end);
    str.getChars(value, start);
    count = newCount;
    return this;
}

// String.java
void getChars(char dst[], int dstBegin) {
    System.arraycopy(value, 0, dst, dstBegin, value.length);
}

replace()方法将指定位置的字符替换成指定字符串中的字符。替换的字符从指定的start位置开始，直到end-1位置。replace()方法也调用了父类AbstractStringBuilder类中对应的方法。

replace()方法首先检查参数的合法性。当end大于value数组中已存储的字符数count时，end取count值。然后调用ensureCapacityInternal()方法确保value数组有足够的容量。接着调用System类的arraycopy()静态方法进行数组拷贝，主要的作用是从start位置开始空出替换的字符串长度len大小的位置。最后，调用String类的getChars()方法将替换的字符串中的字符拷贝到value数组中。这样就完成了替换字符的操作。

charAt()方法

@Override
public synchronized char charAt(int index) {
    if ((index < 0) || (index >= count))
        throw new StringIndexOutOfBoundsException(index);
    return value[index];
}

charAt()方法返回指定索引处的char字符。索引的范围从0到count-1。

toString()方法

@Override
public synchronized String toString() {
    if (toStringCache == null) {
        toStringCache = Arrays.copyOfRange(value, 0, count);
    }
    return new String(toStringCache, true);
}

// Arrays.java
public static char[] copyOfRange(char[] original, int from, int to) {
    int newLength = to - from;
    if (newLength < 0)
        throw new IllegalArgumentException(from + " > " + to);
    char[] copy = new char[newLength];
    System.arraycopy(original, from, copy, 0,
                     Math.min(original.length - from, newLength));
    return copy;
}

toString()方法返回一个表示该字符序列的字符串。当toStringCache缓存不为null时（表示该StringBuffer对象未被修改），直接返回一个表示该字符序列的字符串。反之，当toStringCache缓存为null时（表示该StringBuffer对象已被修改），调用Arrays类的copyOfRange()静态方法来创建一个新数组和拷贝value数组中的字符到新数组，并将toStringCache指向新数组，然后才返回一个表示该字符序列的字符串。

通过使用toStringCache缓存，当StringBuffer对象未被修改时，减少了一次创建新数组和拷贝数组的开销。

总结

StringBuffer类将所有操作字符序列的方法都添加了 synchronized 关键字来修饰，因此，StringBuffer类是线程安全的。

1. StringBuffer类使用了一个char数组来存储字符。该数组是一个动态的数组，当存储容量不足时，会对它进行扩容。
2. StringBuffer对象是一个可变的字符序列。
3. StringBuffer类是线程安全的。

问题

根据以上源码解析，可以衍生出几个问题

1. String，StringBuffer，StringBuilder的区别 ？
答：String是字符串内容不可变的，而StringBuffer和StringBuilder是字符串内容长度可变的；
      StringBuffer是同步的，数据安全，效率低。
      StringBuilder是不同步的，数据不安全，效率高。
（1）. 在执行速度方面的比较：StringBuilder > StringBuffer
（2）. StringBuffer与StringBuilder，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，不像String一样创建一些对象进行操作，所以速度就快了。
（3）. StringBuilder：线程非安全的
　       StringBuffer：线程安全的
  当我们在字符串缓冲去被多个线程使用是，JVM不能保证StringBuilder的操作是安全的，虽然他的速度最快，但是可以保证StringBuffer是可以正确操作的。当然大多数情况下就是我们是在单线程下进行的操作，所以大多数情况下是建议用StringBuilder而不用StringBuffer的，就是速度的原因。
对于三者使用的总结：• 如果要操作少量的数据用 = String
　　　　　　            • 单线程操作字符串缓冲区 下操作大量数据 = StringBuilder
　　　　　　            • 多线程操作字符串缓冲区 下操作大量数据 = StringBuffer
注意：为什么StringBuffer具有数据安全的特性?
		因为很多方法都是synchronized 

2. StringBuffer 和数组的区别？
答：二者都可以看出是一个容器，装其他的数据。但是呢，StringBuffer的数据最终是一个字符串数据，而数组可以放置任意类型的同一种数据。

3. 形式参数问题。
		String作为参数传递
		StringBuffer作为参数传递
   形式参数：	
        基本类型：形式参数的改变不影响实际参数
        引用类型：形式参数的改变直接影响实际参数
-------------------------以下是案例----------------------------
/*
 * 形式参数问题：
 * String作为参数传递
 * StringBuffer作为参数传递 
 * 
 * 形式参数：
 *         基本类型：形式参数的改变不影响实际参数
 *         引用类型：形式参数的改变直接影响实际参数
 * 
 * 注意：
 *         String作为参数传递，效果和基本类型作为参数传递是一样的。
 */
public class StringBufferDemo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1 + "---" + s2);// hello---world
        change(s1, s2);
        System.out.println(s1 + "---" + s2);// hello---world

        StringBuffer sb1 = new StringBuffer("hello");
        StringBuffer sb2 = new StringBuffer("world");
        System.out.println(sb1 + "---" + sb2);// hello---world
        change(sb1, sb2);
        System.out.println(sb1 + "---" + sb2);// hello---worldworld

    }

    public static void change(StringBuffer sb1, StringBuffer sb2) {
        sb1 = sb2;
        sb2.append(sb1);
    }

    public static void change(String s1, String s2) {
        s1 = s2;
        s2 = s1 + s2;
    }
}


---------------------运行结果---------------------
hello---world
hello---world
hello---world
hello---worldworld

参考

JDK-StringBuffer类