我写了四种不同的方法来拼接字符串：用+=，+，StringBuffer，StringBuilder。代码如下：

1. public class PerformanceTest {
   
2.         long times;
   
3.         public PerformanceTest(long times) {
   
4.                 this.times = times;
   
5.         }
   
6.         
   
7.         public PerformanceTest start(String title, PerformanceTest.Perform performance) {
   
8.                 long start = System.nanoTime();
   
9.                
   
10.                 for (int i = 0; i < times; i++) {
    
11.                         performance.perform();
    
12.                 }
    
13.                
    
14.                 System.out.println((System.nanoTime() - start) + "(" + title + ")");
    
15.                
    
16.                 return this;
    
17.         }
    
18.         
    
19.         protected interface Perform{
    
20.                 public void perform();
    
21.         }
    
22. }

复制代码

上面是用来测试的通用类，下面是具体的测试代码：

1. public class StringConcatTest {
   
2.         
   
3.         public static void main(String... args) {
   
4.                 new PerformanceTest(1000000).start("用+=", new PerformanceTest.Perform() {
   
5.                         @Override
   
6.                         public void perform() {
   
7.                                 concat1("aaaa", "bbbb", "cccc", "dddd", "eeee", "ffff");
   
8.                         }
   
9.                 }).start("用StringBuffer", new PerformanceTest.Perform() {
   
10.                         @Override
    
11.                         public void perform() {
    
12.                                 concat2("aaaa", "bbbb", "cccc", "dddd", "eeee", "ffff");
    
13.                         }
    
14.                 }).start("用+", new PerformanceTest.Perform() {
    
15.                         @Override
    
16.                         public void perform() {
    
17.                                 concat3("aaaa", "bbbb", "cccc", "dddd", "eeee", "ffff");
    
18.                         }
    
19.                 }).start("用StringBuilder", new PerformanceTest.Perform() {
    
20.                         @Override
    
21.                         public void perform() {
    
22.                                 concat4("aaaa", "bbbb", "cccc", "dddd", "eeee", "ffff");
    
23.                         }
    
24.                 });
    
25.         }
    
26.         
    
27.         static String concat1(String s1, String s2, String s3, String s4, String s5, String s6){
    
28.                 String result = "";
    
29.                 result += s1;
    
30.                 result += s2;
    
31.                 result += s3;
    
32.                 result += s4;
    
33.                 result += s5;
    
34.                 result += s6;
    
35.                
    
36.                 return result;
    
37.         }
    
38.         
    
39.         static String concat2(String s1, String s2, String s3, String s4, String s5, String s6){
    
40.                 StringBuffer buffer = new StringBuffer();
    
41.                 buffer.append(s1).append(s2).append(s3).append(s4).append(s5).append(s6);
    
42.                
    
43.                 return buffer.toString();
    
44.         }
    
45.         
    
46.         static String concat3(String s1, String s2, String s3, String s4, String s5, String s6){
    
47.                 return s1 + s2 + s3 + s4 + s5 + s6;
    
48.         }
    
49.         
    
50.         static String concat4(String s1, String s2, String s3, String s4, String s5, String s6){
    
51.                 StringBuilder builder = new StringBuilder();
    
52.                 builder.append(s1).append(s2).append(s3).append(s4).append(s5).append(s6);
    
53.                
    
54.                 return builder.toString();
    
55.         }
    
56. }

复制代码

在我机器上运行1000000次的结果如下：

364650466(用+=)
266889252(用StringBuffer)
9372288(用+)
109691345(用StringBuilder)


下面分析下结果：
用+=和+操作本质就是调用StringBuolder的append方法。
第一种之所以最差是因为每次链接都要重新创建一个字符串
第二种方法虽然用到了StringBuffer，但是我估计是因为线程同步导致效率低
主要是第三和第四种，下面是我截的两种方法的字节码：


第三种：


第四种：




我看着两段代码似乎没有什么太大的不同，为什么效率会差那么多？

看来看去，只有第三种少调用一次append这个解释了