java中String,StringBuffer,StringBuilder拼接效率对比

比较JAVA中String ,StringBuffer,SrtingBuilder三个对象连接字符串的效率。 

我们经常都听有经验的人说，避免使用String通过“+”连接字符串，特 

别是连接的次数很多的时候，一定要用StringBuffer。

测试代码：

[java] view plain copy

 

1. package com.panther.demo.exercise6;  
2.   
3. /** 
4.  * String,StringBuffer,StringBuilder字符串拼接效率对比 
5.  * Created by panther.dongdong on 2016/3/10. 
6.  */  
7. public class StringConnectTimeDemo {  
8.     private final int n = 200000;  
9.   
10.     public static void main(String[] args) {  
11.         StringConnectTimeDemo stringConnectTimeDemo = new StringConnectTimeDemo();  
12.         stringConnectTimeDemo.stringTest();  
13.         stringConnectTimeDemo.stringBufferTest();  
14.         stringConnectTimeDemo.stringBuilderTest();  
15.     }  
16.   
17.     public void stringTest() {  
18.         long start = System.currentTimeMillis();  
19.         String s = "";  
20.         for (int i = 0; i < n; ++i) {  
21.             s += i;  
22.         }  
23.         System.out.println("string cost time:" + (System.currentTimeMillis() - start));  
24.     }  
25.   
26.     public void stringBufferTest() {  
27.         long start = System.currentTimeMillis();  
28.         StringBuffer s = new StringBuffer("");  
29.         for (int i = 0; i < n; ++i) {  
30.             s.append(i);  
31.         }  
32.         System.out.println("stringBuffer cost time:" + (System.currentTimeMillis() - start));  
33.     }  
34.   
35.     public void stringBuilderTest() {  
36.         long start = System.currentTimeMillis();  
37.         StringBuilder s = new StringBuilder("");  
38.         for (int i = 0; i < n; ++i) {  
39.             s.append(i);  
40.         }  
41.         System.out.println("stringBuilder cost time:" + (System.currentTimeMillis() - start));  
42.     }  
43. }  

当拼接次数打到200000时，效果就非常明显了，

结果：

由上边的图可以清楚的看出，为什么大家都鼓励用StringBuffer连接字符串了。在连接次数少 
的情况下，String的低效率表现并不是很突出，但是一旦连接次数多的时候，性能影响是很大的，String进 
行20万次字符串的连接，大约需要45s时间，而StringBuffer只需要10毫秒，相差接近5000倍以上。而 
StringBuffer和StringBuilder差别并不大，StringBuilder比StringBuffer稍微快点，我想是因为StringBuffer 
是线程序安全的，StringBuilder不是线程序安全的，所以StringBuffer稍微慢点。 

但是为什么String如此慢呢，分析以下代码 
String result=""; 
result+="ok"; 
这段代码性能很低，原因是java中的String类不可变的（immutable）， 
通过使用javap工具我们可以知道其实上面的代码在编译成字节码的时候等同的源代码是： 
String result=""; 
StringBuffer temp=new StringBuffer(); 
temp.append(result); 
temp.append("ok"); 
result=temp.toString(); 
短短的两个语句怎么呢变成这么多呢？问题的原因就在String类的不可变性上。 

所以，如果你对字符串中的内容经常进行操作，特别是内容要修改时，那么使用StringBuffer，如果最后 
需要String，那么使用StringBuffer的toString()方法好了。但是 StringBuilder 的实例用于多个线程是不安 
全的。如果需要这样的同步，则建议使用 StringBuffer，因为StringBuffer是线程安全的。在大多数非多 
线程的开发中，为了提高效率，可以采用StringBuilder代替StringBuffer，速度更快。

补充：

 

[java] view plain copy

 

1. public static String concat1(String s1, String s2, String s3, String s4, String s5, String s6) {  
2.         String result = "";  
3.         result += s1;  
4.         result += s2;  
5.         result += s3;  
6.         result += s4;  
7.         result += s5;  
8.         result += s6;  
9.         return result;  
10.     }  
11.   
12.     public static String concat2(String s1, String s2, String s3, String s4, String s5, String s6) {  
13.         StringBuffer result = new StringBuffer();  
14.         result.append(s1);  
15.         result.append(s2);  
16.         result.append(s3);  
17.         result.append(s4);  
18.         result.append(s5);  
19.         result.append(s6);  
20.         return result.toString();  
21.     }  
22.   
23.     public static String concat3(String s1, String s2, String s3, String s4, String s5, String s6) {  
24.         return new StringBuffer(s1.length() + s2.length() + s3.length() + s4.length() + s5.length() + s6.length())  
25.                 .append(s1).append(s2).append(s3).append(s4).append(s5).append(s6).toString();  
26.     }  
27.   
28.     public static String concat4(String s1, String s2, String s3, String s4, String s5, String s6) {  
29.         return s1 + s2 + s3 + s4 + s5 + s6;  
30.     }  
31.   
32.     public static String concat5(String s1, String s2, String s3, String s4, String s5, String s6) {  
33.         return new StringBuilder(s1.length() + s2.length() + s3.length() + s4.length() + s5.length() + s6.length())  
34.                 .append(s1).append(s2).append(s3).append(s4).append(s5).append(s6).toString();  
35.     }   

第一种写法是最土的写法，也最累赘，事实上看到这样的代码我都会有点头疼。 
看过《Effective Java》的朋友都知道用StringBuffer吧，用第二种写法的人应该也不少。 
第4种写法当然最简捷，最优美的了，就是不知道性能怎么样。 
Java 5里加了个StringBuilder类，与StringBuffer功能一样，就是没有同步， 
所有用StringBuilder代替StringBuffer肯定对性能有好处，这样就产生的第5种写法。 

还是做个测试有说服力。我的机器上同时装了JDK 5和JDK 6，两个都测了一下。 
执行每个函数10000000次（输入的每个参数都是"a"），各种写法用时如下，单位毫秒： 

JDK 5: 
concat1: 13776 
concat2: 5081 
concat3: 4944 
concat4: 4202 
concat5: 4047 

JDK 6: 
concat1: 11801 
concat2: 3930 
concat3: 3976 
concat4: 3353 
concat5: 3440 

可以看出第1种写法果然最慢，第二种写法由于用了StringBuffer，快了很多。 
奇怪的是第4种写法竟然也很快，比用StringBuffer还快，怎么回事？ 
其实如果你调试过字符串连接的执行过程就会知道当用第4种写法时Java会自动使用StringBuilder.append()函数来进行连接。 
所以最简捷的第4种写法已经够快了。 
在JDK 5里，第5种写法最快，因为在创建StringBuilder的时候预先计算了总长度，消除了内存重分配。 
不过没有必要这么写，JDK 6里已经为第4种写法做了更好的优化，第5种写法反而慢了。

http://blog.csdn.net/liu136313/article/details/50851100