StringBuilder StringBuffer --阅读源码从jdk开始

引言

 

最近我的同事分享了一个页面渲染过程中，字符串拼接的优化处理。我们系统的页面渲染是分模块渲染，每个模块渲染完成后都是一个String型的html片段，最终我们需要把所有模块的html片段拼接成一个完整html页面。老代码逻辑大致如下：

        List<String> moudleHtmls = new ArrayList<>(moduleSize);
        for(int i=0;i<moduleSize;i++){
            String tempHtml = null;
            //模块内容渲染 省略代码
            moudleHtmls.set(i, tempHtml);//把每个模块html片段放入List
        }
       
        String pageString="";
        for (int i=0;i <moduleSize; i++){
            pageString+=moudleHtmls.get(i);//遍历把所有模块的html片段拼接成一个页面
        }

通过反编译发现第二个for循环，每次拼接操作都会自动生成一个StringBuilder对象，反编译的代码如下（第二个for循环部分）：

        String pageString="";
        for (int i=0;i <moduleSize; i++){
            pageString=new StringBuilder().append(pageString).append(moudleHtmls.get(i)).toString();
        }
 

 

每次for循环都会生成一个StringBuilder，其默认容量为16，超过16又需要自动扩容（后面源码详细讲解），势必会影响性能。改进后的代码如下：

StringBuilder pageString = new StringBuilder(pageTemplate.length * 2);//预估页面长度
for (int i=0;i <moduleSize; i++){
            pageString.append(moudleHtmls.get(i));//遍历把所有模块的html片段拼接成一个页面
        }

通过对比发现改造后的拼接性能大幅提升。我们系统每天都有上百万次的页面渲染，这个小小的改动带来的收益是可想而知的。

为了对StringBuilder有更深入的了解，决定阅读其相关源码，做一次全面的总结。

 

字符串连接的三种方式

 

1、字符串连接操作符（+），是把多个字符串合并为一个字符串的便利途径。

2、 StringBuilder，创建该类对象，调用其append方法实现字符串连接，从jdk1.5开始支持。

3、StringBuffer，用法和StringBuilder相同，从jdk1.0就开始支持。

 

通过阅读源码发现StringBuilder、StringBuffer都是继承自AbstractStringBuilder，方式实现也是基本相同，只是StringBuffer的每个方式都是synchronized修饰的，也就是说StringBuffer适合使用在多线程并发环境下的字符串拼接。单线程环境下使用StringBuilder的性能会更好些。

 

String t=“123”+“456”；

这种方式每次执行，本质上是创建一个新String，然后把两个String的的内容复制到这个新String，性能非常差。但从jdk1.5开始，该操作做了优化，执行过程中会自动new 一个StringBuilder，真实的执行过程变为：String t=new StringBuilder().append(“123”).append(“456”)。

 

也就是说在拼接后的字符串总长度比较短的情况下（总长度不超过16），直接使用“(+)”符号拼接是最佳选择。

如果拼接后的字符串总长度大于16，最好新建一个指定预估容量的StringBuilder，调用其append方法进行拼接。如上述优化中：

StringBuilder pageString = new StringBuilder(pageTemplate.length * 2);//预估页面长度

 

另外如果在for循环中也不建议直接使用(+)操作，因为这会导致每次循环都会新创建一个StringBuilder，如上述优化中主要就是优化这个问题。

 

为什么要指定StringBuilder容量，其实跟ArrayList、HashMap等原理相同，都存在自动扩容的问题，看下源码就一目了然。

 

StringBuilder、StringBuffer、AbstractStringBuilder 源码解析

 

StringBuilder、StringBuffer都是继承自AbstractStringBuilder抽象类，每个方法的实现基本相同，都是调用AbstractStringBuilder中的方法。唯一的差异，就是toString方法，方法也是AbstractStringBuilder中唯一的抽象方法。

 

成员变量是一个char性的数组，StringBuilder、StringBuffer的所有操作基本都是围绕这个数组进行：

char[] value;//在AbstractStringBuilder中定义

该字符数组在StringBuilder、StringBuffer的初始默认容量都是16，方法操作完全相同，以StringBuilder为例：

//默认构造方法
public StringBuilder() {
        super(16);//默认容量
}
//指定容量构造方法
public StringBuilder(int capacity) {
        super(capacity);
}
//指定初始字符串构造方法
public StringBuilder (String str) {
        super(str.length() + 16); //初始容量为字符串长度+16
        append(str);
}

 

这里通过super调用AbstractStringBuilder的构造方法：

AbstractStringBuilder(int capacity) {
        value = new char[capacity];//指定数组容量，初始化字节数组
}

 

成员变量字节数组value初始化完成。

 

append系列重载方法

 

AbstractStringBuilder中的append系列重载方法（StringBuilder、StringBuffer 中的append方法通过super直接调用该系列方法），是其核心方法，可以处理处理所有的基础类型（比如boolean、int、long、double等）、引用类型的拼接（String、Object、AbstractStringBuilder自身等），这里以用得最多的append(String)进行讲解：

public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();//注意如果为str为null，会拼接一个"null"字符串
        int len = str.length();
        ensureCapacityInternal(count + len);//判断容量是否足够，如不够先扩容，再copy到新扩容后的数组
        str.getChars(0, len, value, count);//把str copy到 字符数组中
        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;//扩容两倍 + 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); //把老数据复制到扩容后的新数组。
    }
 

 

StringBuilder、StringBuffer的字符串拼接，实际上就是把待拼接的字符串，放到自己的字符数组，如果字符数组的容量不够，需要进行扩容。具体操作是新创建一个字符数组（容量为老数组的2倍+2），再把老数组中的内容copy到新数组。这就是为什么在拼接大量字符串（拼接后超过长度16），最好采用指定容量的方式创建StringBuilder（或StringBuffer），防止拼接过程中不断扩容带来的性能消耗。

 

toString方法

 

需要注意的是StringBuilder、StringBuffer不是String类型，不能强制转换。只能通过调用其toString方法转换为String。前面已经提到StringBuilder、StringBuffer重要区别就是toString方法的实现不同。

StringBuilder的toString方法，采用自己成员变量value字符数组新建一个String：

@Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
}
 

StringBuffer的toString方法：

public synchronized String toString() {
        if (toStringCache == null) {
            toStringCache = Arrays.copyOfRange(value, 0, count);//缓存成员变量value字符数组
        }
        return new String(toStringCache, true);
}
 

 

其中toStringCache主要用作缓存。当StringBuffer对成员变量value字符数组有修改时，需要先清理缓存，如StringBuffer的 append(String)方法实现：

@Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;//清理缓存
        super.append(str);//调用父类AbstractStringBuilder的append方法
        return this;
    }
 

 

再来看下StringBuilder的append(String)方法实现：

@Override
    public StringBuilder append(String str) {
        super.append(str);
        return this; //调用父类AbstractStringBuilder的append方法
}
 

 

区别有两点：

1、StringBuffer的方法是synchronized修饰。

2、StringBuffer的方法需要清理缓存。

StringBuilder、StringBuffer的append系列方法不再一一讲解，具体操作都差不多，把待拼接类型转换中字符，依次放到其成员变量value字符数组中。

 

其他方法：

 

AbstractStringBuilder的delete方法，本质上也是对字符数组的copy操作：

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

 

AbstractStringBuilder的insert系列方法，这里以String为例：

public AbstractStringBuilder insert(int offset, String str) {
        if ((offset < 0) || (offset > length()))
            throw new StringIndexOutOfBoundsException(offset);
        if (str == null)
            str = "null";
        int len = str.length();
        ensureCapacityInternal(count + len);//确认容量
        System.arraycopy(value, offset, value, offset + len, count - offset);//通过复制预留出待插入空间
        str.getChars(value, offset);//copy字符串 到指定开始位置
        count += len;
        return this;
    }

 

举个列子:在“hello!”字符串中插入“pig”字符串，形成“hellopig!”, java代码如下：

StringBuilder sb = new StringBuilder；
sb.append(“hello!”)
sb.insert(4,“pig”);

对应的示意图：

 

 

AbstractStringBuilder的reverse方法，本质上就是把字符数组里每个字符反序排列，不在累述。

 

最后总结下：

1、拼接完成的字符串长度短的情况下，直接使用(+)操作符即可：如String t = “123”+”456”。

2、不要在for循环中使用(+)操作符，使用StringBuilder代替。

3、单线程环境下，使用StringBuilder拼接一个比较长的字符串，最好先预估容量，采用指定容量的StringBuilder构造方法，构造StringBuilder实例。

4、多线程环境下使用StringBuffer。