String、StringBuffer、StringBuilder以及CharSequence

来源：互联网发布：淘宝服装招商加盟代理编辑：程序博客网时间：2024/06/01 10:47

1、从类的定义看CharSequence、StringBuffer、StringBuilder、String的关系

（来自JDK1.6）

CharSequence是一个定义字符串操作的接口，StringBuffer、StringBuilder、String中都实现了这个接口.

//CharSequence定义public interface CharSequence//StringBuffer定义 public final class StringBuffer    extends AbstractStringBuilder    implements java.io.Serializable, CharSequence//StringBuilder定义public final class StringBuilder    extends AbstractStringBuilder    implements java.io.Serializable, CharSequence//String定义public final class String    implements

java.io.Serializable, Comparable<String>, CharSequence

可以看出，String 继承于CharSequence，也就是说String也是CharSequence类型 (String的本质是字符序列，它是通过字符数组实现的)。

CharSequence是一个接口，它包括length(), charAt(int index), subSequence(int start, int end)这几个API接口。除了String实现了CharSequence之外，StringBuffer和StringBuilder也实现了CharSequence接口。
也就是说，CharSequence其实也就是定义了字符串操作的接口，其他具体的实现是由String、StringBuilder、StringBuffer完成的，String、StringBuilder、StringBuffer都可以转化为CharSequence类型。

StringBuilder 和 StringBuffer 的区别

StringBuilder 和 StringBuffer都是可变的字符序列。它们都继承于AbstractStringBuilder，实现了CharSequence接口。
但是，StringBuilder是非线程安全的，而StringBuffer是线程安全的。

它们之间的关系图如下：

2、从构造函数到具体的字符串拼接操作看String、StringBuffer、StringBuilder的区别

下面我们来分析一下String、StringBuffer、StringBuilder具体的构造函数，了解他们是怎么构造出来的，再看看具体的字符串连接操作。

（1）String

String的构造函数(几个常见的构造函数)

public String() {        this.offset = 0;        this.count = 0;        this.value = new char[0];    }    /**     * Initializes a newly created {@code String} object so that it represents     * the same sequence of characters as the argument; in other words, the     * newly created string is a copy of the argument string. Unless an     * explicit copy of {@code original} is needed, use of this constructor is     * unnecessary since Strings are immutable.     *     * @param  original     *         A {@code String}     */    public String(String original) {        int size = original.count;        char[] originalValue = original.value;        char[] v;        if (originalValue.length > size) {            // The array representing the String is bigger than the new            // String itself.  Perhaps this constructor is being called            // in order to trim the baggage, so make a copy of the array.            int off = original.offset;            v = Arrays.copyOfRange(originalValue, off, off + size);        } else {            // The array representing the String is the same            // size as the String, so no point in making a copy.            v = originalValue;        }        this.offset = 0;        this.count = size;        this.value = v;    }    /**     * Allocates a new {@code String} so that it represents the sequence of     * characters currently contained in the character array argument. The     * contents of the character array are copied; subsequent modification of     * the character array does not affect the newly created string.     *     * @param  value     *         The initial value of the string     */    public String(char[] value) {        this.offset = 0;        this.count = value.length;        this.value = StringValue.from(value);    }

再看看String中具体的Concat函数

public String concat(String str) {        int otherLen = str.length();        if (otherLen == 0) {            return this;        }        char[] buf = new char[count + otherLen];        getChars(0, count, buf, 0);        str.getChars(0, otherLen, buf, count);        return new String(0, count + otherLen, buf);    }

从Concat函数中，我们可以知道在对字符串使用concat操作后，具体的操作new出一个等同于两个字符串连接总长度的新的char数组，然后将两个字符串复制到新的char数组中，然后返回一个新的String对象。

（2）StringBuilder

StringBuilder常见构造函数

    public StringBuffer() {        super(16);

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

从StringBuilder的构造函数中，我们可以看见StringBuilder直接调用父类（AbstractStringBuilder）的构造函数，我们再看看AbstractStringBuilder的构造函数

abstract class AbstractStringBuilder implements Appendable, CharSequence {    final static int[] sizeTable = {            9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,            Integer.MAX_VALUE        };    /**     * The value is used for character storage.     */    char[] value;    /**     * The count is the number of characters used.     */    int count;    /**     * This no-arg constructor is necessary for serialization of subclasses.     */    AbstractStringBuilder() {    }    /**     * Creates an AbstractStringBuilder of the specified capacity.     */    AbstractStringBuilder(int capacity) {        value = new char[capacity];    }//其他的一些逻辑}

从AbstractStringBuilder的构造函数中，我们可以看出StringBuilder中存储字符串其实用的是一个char数组，capacity其实就是指定这个char数组的大小。

下面我们再从StringBuilder中的append函数看看他具体是怎么做的(以 append(String str) 为例看看)。

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

又是直接调用父类（AbstractStringBuilder）的append方法，再跟到父类中去看看。

/**     *  value 用来存储字符串.     */    char value[];    /**      * 有效字符串的数目.     */    int count;    public AbstractStringBuilder append(String str) {        if (str == null) {            str = "null";        }        int len = str.length();        if (len == 0) {            return this;        }        int newCount = count + len;        if (newCount > value.length) {            expandCapacity(newCount);        }       //getChars将字符串复制到指定的位置        str.getChars(0, len, value, count);        count = newCount;        return this;    }

上面的逻辑还是比较简单的，在append(str)函数调用的时候，首先会判断原来用于存储字符串的values的字符串数组有没有足够的大小来存储将要新添加入StringBuilder的字符串。如果不够用，那么就调用expandCapacity(int minimumCapacity)让容量翻两倍(一般是扩大两倍，特殊情况见代码)，如果够用，那么就直接添加进去。

/**     * This implements the expansion semantics of ensureCapacity with no     * size check or synchronization.     */    void expandCapacity(int minimumCapacity) {        int newCapacity = (value.length + 1) * 2;        if (newCapacity < 0) {            newCapacity = Integer.MAX_VALUE;        } else if (minimumCapacity > newCapacity) {            newCapacity = minimumCapacity;        }        value = Arrays.copyOf(value, newCapacity);    }

（3）StringBuffer

StringBuffer的构造函数

/**     * Constructs a string buffer with no characters in it and an      * initial capacity of 16 characters.      */    public StringBuffer() {    super(16);    }    /**     * Constructs a string buffer with no characters in it and      * the specified initial capacity.      *     * @param      capacity  the initial capacity.     * @exception  NegativeArraySizeException  if the <code>capacity</code>     *               argument is less than <code>0</code>.     */    public StringBuffer(int capacity) {    super(capacity);    }

StringBuffer也是直接调用父类（AbstractStringBuilder）的构造函数，那么我们从上面的分析中，就可以知道StringBuffer其实也是利用char[]类型的数组来保存字符串数组的。

再看看StringBuffer的append函数

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

还是调用父类的append函数，但是在这里有值得注意的地方，StringBuffer的append函数有一个synchronized标识符，也就是说StringBuffer中的append函数是线程安全的，通过继续查阅其他StringBuffer中的函数，我们也可以发现他们有synchronized标识符，这就不难理解为什么StringBuffer是线程安全的，但是很明显加上线程控制会拖慢程序运行的速度，所以如果不需要线程控制，那么最好就用StringBuilder。

//下面只是节选一些StringBuffer中的函数synchronized StringBuffer     append(char ch)synchronized StringBuffer     append(char[] chars)synchronized StringBuffer     append(char[] chars, int start, int length)synchronized StringBuffer     append(Object obj)synchronized StringBuffer     append(String string)synchronized StringBuffer     append(StringBuffer sb)synchronized StringBuffer     append(CharSequence s)synchronized StringBuffer     append(CharSequence s, int start, int end)synchronized StringBuffer     insert(int index, char ch)synchronized StringBuffer     insert(int index, char[] chars)synchronized StringBuffer     insert(int index, char[] chars, int start, int length)synchronized StringBuffer     insert(int index, String string)StringBuffer     insert(int index, Object obj)