Java 5種字串拼接方式效能比較。

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

 

代碼如下：

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

 

運行結果如下：

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支援。