最近寫一個東東，可能會考慮到字串拼接，想了幾種方法，但對效能未知，於是用Junit寫了個單元測試。

程式碼如下：

1. import java.util.ArrayList;
2. import java.util.List;
3. import org.apache.commons.lang.StringUtils;
4. import org.junit.Test;
5. import org.slf4j.Logger;
6. import org.slf4j.LoggerFactory;
7. publicclass TestString {
8. privatefinal Logger logger = LoggerFactory.getLogger(
   this.getClass());
9. @Test
10. publicvoid testPlus() {
11.         String s = "";
12. long ts = System.currentTimeMillis();
13. for (int i = 0; i < 10000; i++) {
14.             s = s + String.valueOf(i);
15.         }
16. long te = System.currentTimeMillis();
17.         logger.info("+ cost {} ms", te - ts);
18.     }
19. @Test
20. publicvoid testConcat() {
21.         String s = "";
22. long ts = System.currentTimeMillis();
23. for (int i = 0; i < 10000; i++) {
24.             s = s.concat(String.valueOf(i));
25.         }
26. long te = System.currentTimeMillis();
27.         logger.info("concat cost {} ms", te - ts);
28.     }
29. @Test
30. publicvoid testJoin() {
31.         List<String> list = 
    new ArrayList<String>();
32. long ts = System.currentTimeMillis();
33. for (int i = 0; i < 10000; i++) {
34.             list.add(String.valueOf(i));
35.         }
36.         StringUtils.join(list, "");
37. long te = System.currentTimeMillis();
38.         logger.info("StringUtils.join cost {} ms", te - ts);
39.     }
40. @Test
41. publicvoid testStringBuffer() {
42.         StringBuffer sb = new StringBuffer();
43. long ts = System.currentTimeMillis();
44. for (int i = 0; i < 10000; i++) {
45.             sb.append(String.valueOf(i));
46.         }
47.         sb.toString();
48. long te = System.currentTimeMillis();
49.         logger.info("StringBuffer cost {} ms", te - ts);
50.     }
51. @Test
52. publicvoid testStringBuilder() {
53.         StringBuilder sb = new StringBuilder();
54. long ts = System.currentTimeMillis();
55. for (int i = 0; i < 100000; i++) {
56.             sb.append(String.valueOf(i));
57.         }
58.         sb.toString();
59. long te = System.currentTimeMillis();
60.         logger.info("StringBuilder cost {} ms", te - ts);
61.     }
62. }

執行結果如下：

11:00:22,359  INFO TestString:23 - + cost 1828 ms
11:00:22,921  INFO TestString:34 - concat cost 562 ms
11:00:22,937  INFO TestString:46 - StringUtils.join cost 16 ms
11:00:22,968  INFO TestString:58 - StringBuffer cost 31 ms
11:00:23,031  INFO TestString:70 - StringBuilder cost 63 ms

要特別注意的是：

StringBuilder 迴圈的次數是其它的10倍，如果是一樣，那麼返回 0，可見StringBuilder 的速度之快。

總結：

用+的方式效率最差，concat由於是內部機制實現，比+的方式好了不少。

Join 和 StringBuffer，相差不大，Join方式要快些，可見這種JavaScript中快速拼接字串的方式在Java中也非常適用。

StringBuilder 的速度最快，但其有執行緒安全的問題，而且只有JDK5支援。