从源码的角度解读String、StringBuilder、StringBuffer的性能差别

首先我们来看一段程序

package more;
/**
 * 测试string StringBuffer StringBuilder的性能
 * @author ybsem
 *
 */
public class SSbSb {
    public static void main(String[] args) {
        String string = "s";
        StringBuilder stringBuilder = new StringBuilder("s");
        StringBuffer stringBuffer = new StringBuffer("s");
        
        Long startString = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            string = string + i;
        }
        Long endString = System.currentTimeMillis();
        System.out.println("创建string常量时间为:"+(endString-startString));
        
        Long startStringBuilder = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            stringBuilder = stringBuilder.append(i);
        }
        Long endStringBuilder =System.currentTimeMillis();
        System.out.println("创建stringBuilder对象时间为:"+(endStringBuilder-startStringBuilder));
        
        Long startStringBuffer = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            stringBuffer = stringBuffer.append(i);
        }
        Long endStringBuffer = System.currentTimeMillis();
        System.out.println("创建stringBuffer对象时间为:"+(endStringBuffer-startStringBuffer));
        
    }
}

测试结果

由此我们可以从性能上看出String<StringBuffer<StringBuilder

现在我们从源码的角度来解读下为什么出现这种问题

String

---

 首先来看String的核心代码

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
   private final char value[];//final类型char数组
//省略其他代码……
……
}

由此可以看出一个String string = “s”其实是一个字符数组，并且是不可变的10000; i++) { string = string + i; }

这段代码其实相当于创建了一万个新的String对象，所以有大量对字符串的操作时不宜使用String

StringBuilder

 我们来看下StringBuilder的核心源码

@Override
    public StringBuilder append(Object obj) {
        return append(String.valueOf(obj));  //当传入的是一个对象时先将其转换为String类型
    }

    @Override
    public StringBuilder append(String str) {
        super.append(str);  //执行父类的append（）方法，他的父类为AbstractStringBuilder

        return this;
    }

//StringBuilder的父类append（）方法public AbstractStringBuilder append(String str) {
        if (str == null)
            return appendNull();
        int len = str.length();
        ensureCapacityInternal(count + len);  //扩容函数
        str.getChars(0, len, value, count);     //value是原字符串的值
/*
 * 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); //是一个本地        //方法用将两个字符串相连，通过数组的copy
 * }
*
*/
       count += len;   //conut初始值为0，第一次执行append（）方法时count变为字符        //串的值
        return this;
    }

由上边的源码可以看出StringBuilder是通过底层数组进行连接的效率高，但同时也应该看到该段代码没有进行同步，所以在多线程环境下是不安全的

StringBuffer

---

再来看StringBuffer的源码

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

 /父类的appen（）的方法

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

//源码与StringBuilder基本相同

StringBuffer与StringBuilder的区别在于将append（）进行了同步，保证了多线程条件下的安全性，但在获得安全性的同时牺牲了性能，所以StringBuffer要比StringBuilder要快的原因

总结如下：

• 在进行少量对字符串的操作时使用String
• 在多线程环境下，并且对字符串操作次数较多则使用StringBuffer
• 在单线程环境下，并且对字符串操作次数较多则使用StringBuilde

分析完性能我们再来详细的分析下append（）方法

---

先来分析String的构造函数

/** The value is used for character storage. */
    private final char value[];

     /* 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.
     */
public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

有这段代码可知以及代码注释可知，string其实是一个数组，由于他是一个不可变类，新创建的字符串是参数字符串的副本。 所以呢除非需要这个副本，否则没必要用这个构造函数来进行创造。String类的字符串串创建时数组的大小是由字符串常量池也就是jvm来进行分配的。具体我们可以来分析下StringBuilder

先来看一段stringBuilder的构造函数

 1    /**
 2      * Constructs a string builder with no characters in it and an
 3      * initial capacity of 16 characters.
 4      */
 5     public StringBuilder() {
 6         super(16);
 7     }
 8    /**
 9      * Constructs a string builder with no characters in it and an
10      * initial capacity specified by the {@code capacity} argument.
11      */
12  public StringBuilder(int capacity) {
13         super(capacity);
14     }
15 
16     /**
17      * Constructs a string builder initialized to the contents of the
18      * specified string. The initial capacity of the string builder is
19      * {@code 16} plus the length of the string argument.
20      */
21    public StringBuilder(String str) {
22         super(str.length() + 16);
23         append(str);
24     }

 /**上述构造函数调用super函数
     * Creates an AbstractStringBuilder of the specified capacity.
     */
    AbstractStringBuilder(int capacity) {
        value = new char[capacity];
    }

这段代码清晰的看出他是基于数组构建的。初始大小为16，stringBuilder继承子AbstractStringBuilder。其次需要了解下他的一个很用要的方法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;
    }

    public void ensureCapacity(int minimumCapacity) {
        if (minimumCapacity > 0)
            ensureCapacityInternal(minimumCapacity);
    }
    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);
    }

检查数组大小是否足够分三步，count+len其实就是新字符床的长度（count旧字符串的长度len需要连接字符串的额长度），若最小长度也就是count+len小于0，不做任何事返回，因为这代表没有任何意义。若大于零则执行ensureCapacityInternal方法，value.length代表的是连接前的字符串的值，若新字符串也就是连接后字符串的大小大于旧字符串的长度，则代表数组大小可能不够用，进行扩容。执行expandCapacity方法，扩容后大小为length*2+2。这是很可怕的，如果在构造的时候没有指定容量，那么很有可能在扩容之后占用了浪费大量的内存空间。使用StringBuilder或者StringBuffer时，尽可能准确地估算capacity，并在构造时指定，避免内存浪费和频繁的扩容及复制。扩容之后新申请的数组大小newCapacity小于0同时连接后字符串所需最小空间minimumCapacity也小于0，代表无法申请到足够大的空间，发生内存溢出抛出异常。若申请到改大小的空间之后执行数组的复制，返回连接后的数组，相当于新建了一个字符串的值。

StringBuffer进行复制的原理基本相同。

字符串连接时应该注意

---

若用String类型的字符串通过+进行拼接时，会创建一个新的String对象，你要知道String对象一旦创建就是不能被改变的，要达到字符串拼接的效果，就得不停创建新对象。StringBuilder直到最后sb.toString()才会创建String对象，之前都没有创建新对象，或者在超过数组代表长度的字符串时才进行字符串的创建，故从效率上来讲append（）要优于+