String的"+"-StringBuilder-StringBuffer比较

为了直观比较三者的性能，先做测试如下：

package string;import org.junit.Test;public class Effective {    private final int LOOP_TIMES = 50000;    private final String CONSTANT_STRING = "min-snail";    public void stringTest() {        long startTime = System.currentTimeMillis();        String test = "";        int loop = LOOP_TIMES;        while (loop-- > 0) {            test += CONSTANT_STRING;        }        long endTime = System.currentTimeMillis();        System.out.println("String cost: " + (endTime - startTime));    }    public void stringBuilderTest() {        long startTime = System.currentTimeMillis();        StringBuilder test = new StringBuilder();        int loop = LOOP_TIMES;        while (loop-- > 0) {            test.append(CONSTANT_STRING);        }        test.toString();        long endTime = System.currentTimeMillis();        System.out.println("StringBuilder cost: " + (endTime - startTime));    }    public void stringBufferTest() {        long startTime = System.currentTimeMillis();        StringBuffer test = new StringBuffer();        int loop = LOOP_TIMES;        while (loop-- > 0) {            test.append(CONSTANT_STRING);        }        test.toString();        long endTime = System.currentTimeMillis();        System.out.println("StringBuffer cost: " + (endTime - startTime));    }    @Test    public void test() {        for(int i=0;i<5;i++){            System.out.println(i+"----------------------------------");            stringBufferTest();            stringBuilderTest();        }    }}

测试结果如下：

可以看出，在循环体内多次做字符串加操作，平均速度StringBuilder > StringBuffer >> String “+=”，下面从代码进行分析，StringBuilder，StringBuffer均继承于AbstractStringBuilder，不同的是，StringBuffer中append方法加了synchronized，而StringBuilder没有。

StringBuilder 是 java 为 StringBuffer 提供的一个等价类, 但不保证同步。在不涉及多线程的操作情况下可以简易的替换 StringBuffer 来提升系统性能; StringBuffer 在性能上稍略于 StringBuilder, 但可以不用考虑线程安全问题;

String 的 "+" 符号操作起来简单方便,String 的使用也很简单便捷, java 底层会转换成 StringBuilder 来实现。

测试：

   public static void main(String[] args) {        String a = "hello";        String b = " world";        b = a + b;        System.out.println(b);    }

使用jad对上述代码进行，jad的使用：

（1）保证你要反编译的class 文件和jad.exe放在一个目录下

（2）开始 --> 运行 --> cmd , 找到jad 所在的目录

（3）jad -o -a -s .java Effective.class

反编译后生成的代码如下：

   public static void main(String args[])    {        String s = "hello";    //    0    0:ldc1            #22  <String "hello">    //    1    2:astore_1                String s1 = " world";    //    2    3:ldc1            #23  <String " world">    //    3    5:astore_2                s1 = (new StringBuilder()).append(s).append(s1).toString();    //    4    6:new             #8   <Class StringBuilder>    //    5    9:dup                 //    6   10:invokespecial   #9   <Method void StringBuilder()>    //    7   13:aload_1             //    8   14:invokevirtual   #10  <Method StringBuilder StringBuilder.append(String)>    //    9   17:aload_2             //   10   18:invokevirtual   #10  <Method StringBuilder StringBuilder.append(String)>    //   11   21:invokevirtual   #11  <Method String StringBuilder.toString()>    //   12   24:astore_2                System.out.println(s1);    //   13   25:getstatic       #12  <Field PrintStream System.out>    //   14   28:aload_2             //   15   29:invokevirtual   #15  <Method void PrintStream.println(String)>    //   16   32:return              }

  

可以看出，"+"的底层实现是通过StringBuilder实例的append（）方法来完成的

   在本文开头测试中，使用jconsole查看堆内存的使用情况如下：

    String "+" 每一次都先去创建 StringBuilder 对象, 然后再调 append() 方法来完成。这里的大部分时间都花在了对象的创建上, 而且每个创建出来的对象的生命都不能长久, 朝生夕灭, 因为这些对象创建出来之后没有引用变量来引用它们,那么它们在使用完成时候就处于一种不可到达状态, GC就会不定期的来回收这些垃圾对象。因此会看到上图堆内存中的曲线起伏变化很大。

    值得注意的是，对于String  str="hello"+" world！"的执行却是很快的，因为str在编译期就可以被确定是一个字符常量。当编译完成之后str的值就是 "helloworld！"。