25java的StringBuilder类和StringBuffer类

StringBuilder线程不安全，效率高；StringBuffer线程安全，效率低

new StringBuilder创建长度为16的字符串数组

下面看程序实例：

package testString;

public class stringBuilder {
    public static void main(String[] args) {
        StringBuilder stringBuilder = new StringBuilder();//字符数组初始长度为16
        StringBuilder stringBuilder1 = new StringBuilder(32);//指定字符数组初始长度是32
        StringBuilder stringBuilder2 = new StringBuilder("tyuiop");//字符数组初始长度是"tyuiop"+16=6+16=22
        stringBuilder2.append("#fghjkl");
        System.out.println(stringBuilder2);
        stringBuilder2.append("#1").append("#fada").append("#发达");//通过return this实现方法链
        System.out.println(stringBuilder2);
        for (int i = 0; i < 10; i++) {
            stringBuilder.append(i);
        }
        System.out.println(stringBuilder);
    }
}

运行结果：

程序分析：StringBuilder是位于package java.lang;包下的类，是可变长数组的类。

1. StringBuilder stringBuilder = new StringBuilder(); 创建一个可变长字符数组，但是这个字符数组对象是由默认长度的，源码如下：

public final class StringBuilder
extends AbstractStringBuilder
implements java.io.Serializable, CharSequence
{
/**
     * Constructs a string builder with no characters in it and an
     * initial capacity of 16 characters.
     */
    public StringBuilder() {
        super(16);
    }

其中super(16);调用父类的构造方法，并传参16，我们看父类的有参构造器源码：

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    /**
     * 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(int capacity) {
        value = new char[capacity];
    }
}

由此可见，这个可变长字符数组的初始长度是16。

2. StringBuilder stringBuilder1 = new StringBuilder(32); 直接值得顶字符数组的初始长度为32。源码如下：

    /**
     * Constructs a string builder with no characters in it and an
     * initial capacity specified by the {@code capacity} argument.
     *
     * @param      capacity  the initial capacity.
     * @throws     NegativeArraySizeException  if the {@code capacity}
     *               argument is less than {@code 0}.
     */
    public StringBuilder(int capacity) {
        super(capacity);
    }

调用父类的有参构造方法，并传递参数用户指定长度capacity。

3.StringBuffer stringBuffer2 = new StringBuffer(“tyuiop”); 字符数组初始长度是"tyuiop"+16=6+16=22。这个从初始化的字符数组的内容是：{‘t’,‘y’,‘u’,‘i’,‘o’,‘p’,\u0000,\u0000,…}。源码如下：

    /**
     * Constructs a string builder initialized to the contents of the
     * specified string. The initial capacity of the string builder is
     * {@code 16} plus the length of the string argument.
     *
     * @param   str   the initial contents of the buffer.
     */
    public StringBuilder(String str) {
        super(str.length() + 16);
        append(str);
    }

其中super();方法

    /**
     * Creates an AbstractStringBuilder of the specified capacity.
     */
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

其中append()方法：

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

其中super.append()方法：

    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方法的功能就是拼接字符串：把给定字符串拼接到引用对象的后面。 观察发现每个append方法里面最后面都有return this 语句，this代表当前调用这个方法的对象，也就是谁调用这个方法就返回谁，使用this关键字的好处是可以支持方法链。

---

下面的代码是如何append（添加，追加）字符数组的？

StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < 10; i++) {
    stringBuilder.append("#");//在此处设置断点进行debug
}

当程序运行到断点处时，进入位于StringBuilder类中的append方法,传递的参数是字符”#“，下面看这个append方法的源码：

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

可以看到在此处有调用StringBuilder类的父类的append方法，此时传递的参数是字符”#“那么我们进入StringBuilder类的父类的append方法中：

    /**
     * Appends the specified string to this character sequence.
     * <p>
     * The characters of the {@code String} argument are appended, in
     * order, increasing the length of this sequence by the length of the
     * argument. If {@code str} is {@code null}, then the four
     * characters {@code "null"} are appended.
     * <p>
     * Let <i>n</i> be the length of this character sequence just prior to
     * execution of the {@code append} method. Then the character at
     * index <i>k</i> in the new character sequence is equal to the character
     * at index <i>k</i> in the old character sequence, if <i>k</i> is less
     * than <i>n</i>; otherwise, it is equal to the character at index
     * <i>k-n</i> in the argument {@code str}.
     *
     * @param   str   a string.
     * @return  a reference to this object.
     */
    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;
    }

从上述的源码中发现，这个方法的功能就是先进行原来的字符数组的空间判断，如果空间足够就直接追加，如果不够就按照一定的规则进行扩展，然后再添加。获取完新增字符串的长度之后，进入校验方法ensureCapacityInternal()进行校验原字符数组的空间够不够，源码如下：

    /**
     * For positive values of {@code minimumCapacity}, this method
     * behaves like {@code ensureCapacity}, however it is never
     * synchronized.
     * If {@code minimumCapacity} is non positive due to numeric
     * overflow, this method throws {@code OutOfMemoryError}.
     */
    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

当for循环执行第一次的时候，len = str.length()=1，count=0，所以传递给ensureCapacityInternal() 方法的参数minimumCapacity=1，显然minimumCapacity不可能大于value.length（=16，初始大小）， 那么就不创建新的字符数组。下一步执行str.getChars(0, len, value, count)方法，并传递复制字符串的相关参数，下面是getChars()源码：

/**
     * Copies characters from this string into the destination character
     * array.
     * <p>
     * The first character to be copied is at index {@code srcBegin};
     * the last character to be copied is at index {@code srcEnd-1}
     * (thus the total number of characters to be copied is
     * {@code srcEnd-srcBegin}). The characters are copied into the
     * subarray of {@code dst} starting at index {@code dstBegin}
     * and ending at index:
     * <blockquote><pre>
     *     dstBegin + (srcEnd-srcBegin) - 1
     * </pre></blockquote>
     *
     * @param      srcBegin   index of the first character in the string
     *                        to copy.
     * @param      srcEnd     index after the last character in the string
     *                        to copy.
     * @param      dst        the destination array.
     * @param      dstBegin   the start offset in the destination array.
     * @exception IndexOutOfBoundsException If any of the following
     *            is true:
     *            <ul><li>{@code srcBegin} is negative.
     *            <li>{@code srcBegin} is greater than {@code srcEnd}
     *            <li>{@code srcEnd} is greater than the length of this
     *                string
     *            <li>{@code dstBegin} is negative
     *            <li>{@code dstBegin+(srcEnd-srcBegin)} is larger than
     *                {@code dst.length}</ul>
     */  
	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);
    }

前面三个if语句是进行安全性校验，防止传入不合法的索引数据，如果所有的数据都合法，那么就执行System.arraycopy()方法，这个方法是把新增加的那个字符串追加到原来的字符数组中。具体分析一下System.arraycopy()方法：value是原来创建的字符数组（还未扩容），srcBegin=0，dst是getChar方法传递的参数value[]，srcEnd是getsChar方法传递的参数len,每次追加的都是一个#，所以len=1=srcEnd，dstBegin是getChar方法传递的参数count，随着循环次数增加而增加，srcEnd - srcBegin表示的是len-0,也即是追加的字符串的长度，那么这个方法就是把value[]（是String类里面的value[]）的从srcBegin索引开始的元素复制到dst[]的从dstBegin索引开始共srcEnd - srcBegin个字符的储存空间中。注意：dst[]是形参，它的实参是value[]（是StringBuilder里面的value[] ;）。下面我理解的是，每次循环（StringBuilder类的对象存储空间足够）都会调用一次System.arraycopy()方法进行复制，就是新创建一个String类的字符数组对象存储传递过来的字符串常量（待添加的字符串），然后从头直接复制到StringBuilder类的对象value[]中。

当循环到第17次时（i=16），此时的可变长字符数组的存储空间已经不够用了，需要拓展空间，进入ensureCapacityInternal（）方法中

    private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

newCapacity()方法的源码是：

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

(value.length << 1)中的“<<”是把这个数的二进制左移一位，左移一位就是数值乘以2，右移一位就是数字除以2，也就是说这里把原来的字符数组的长度扩大为原来的2倍加2，最后返回值处使用的是一个三元运算符：简单分析，返回值是newCapacity，就是新的字符数组长度。

PS：移位运算

二进制	十进制
0000 0010	2
左移一位：0000 0100	4
0000 1100	12
右移一位：0000 0110	6

然后调用Arrays.copyOf（）方法，源码如下：

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

可以看到直接创建一个大小为newLength（newCapacity）的新的字符数组copy[]，然后还是调用System.arraycopy()方法，把原来的value[]数组里面的所有元素复制到copy[]数组中，最终赋值给value[]数组。

---

StringBuffer类

• StringBuilder线程不安全，效率高；StringBuffer线程安全，效率低

• StringBuffer类的方法种类与StringBuilder类的方法完全相同，用法也相同，只是StringBuffer类的方法都被synchronized关键词修饰，表示线程安全，调用这里的方法必须要有对象锁，涉及到多线程问题，后续再学习。

---

您可能会好奇为什么博客标题前面要加上数字？是这样的：本人之前在博客园发布自己的学习java的过程，标号以前的博客都那里了，为了不做无用功就不一一搬运，所以就在这边沿用那里的标号，欢迎您去博客园阅读并指出我的博客内容的不足之处。

• 我的博客园地址：https://www.cnblogs.com/fanfada/
• 记录了一个小白自学java的旅程