The "Go" Java 5 string concatenation method performance comparison.

Recently wrote a dongdong, may consider the string splicing, think of several methods, but the performance is unknown, so with JUnit wrote a unit test.

The code is as follows:

2. Import java.util.ArrayList;
4. Import java.util.List;
8. Import Org.apache.commons.lang.StringUtils;
10. Import Org.junit.Test;
12. Import Org.slf4j.Logger;
14. Import Org.slf4j.LoggerFactory;
18. public class TestString {
22. Private final Logger Logger = Loggerfactory.getlogger (This.getclass ());
26. @Test
28. public void Testplus () {
30. String s = "";
32. Long ts = System.currenttimemillis ();
34. for (int i = 0; i < 10000; i++) {
36. s = s + string.valueof (i);
38. }
40. Long te = System.currenttimemillis ();
42. Logger.info ("+ Cost {} MS", Te-ts);
44. }
48. @Test
50. public void Testconcat () {
52. String s = "";
54. Long ts = System.currenttimemillis ();
56. for (int i = 0; i < 10000; i++) {
58. s = S.concat (string.valueof (i));
60. }
62. Long te = System.currenttimemillis ();
64. Logger.info ("concat cost {} MS", Te-ts);
66. }
70. @Test
72. public void Testjoin () {
74. list<string> list = new arraylist<string> ();
76. Long ts = System.currenttimemillis ();
78. for (int i = 0; i < 10000; i++) {
80. List.add (string.valueof (i));
82. }
84. Stringutils.join (List, "");
86. Long te = System.currenttimemillis ();
88. Logger.info ("Stringutils.join Cost {} MS", Te-ts);
90. }
94. @Test
96. public void Teststringbuffer () {
98. StringBuffer sb = new StringBuffer ();
100. Long ts = System.currenttimemillis ();
102. for (int i = 0; i < 10000; i++) {
104. Sb.append (string.valueof (i));
106. }
108. Sb.tostring ();
110. Long te = System.currenttimemillis ();
112. Logger.info ("StringBuffer Cost {} MS", Te-ts);
114. }
118. @Test
120. public void Teststringbuilder () {
122. StringBuilder sb = new StringBuilder ();
124. Long ts = System.currenttimemillis ();
126. for (int i = 0; i < 100000; i++) {
128. Sb.append (string.valueof (i));
130. }
132. Sb.tostring ();
134. Long te = System.currenttimemillis ();
136. Logger.info ("StringBuilder Cost {} MS", Te-ts);
138. }
140. }

The results of the operation are as follows:

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 ms
11:00:22,968 INFO teststring:58-stringbuffer Cost ms
11:00:23,031 INFO teststring:70-stringbuilder Cost + ms

Special attention is paid to the following:

The number of StringBuilder cycles is 10 times times that of the other, and if it is the same, then return 0, visible StringBuilder speed.

Summarize:

In the way of the worst efficiency, concat because it is the internal mechanism to achieve, more than the way of a lot better.

Join and StringBuffer, the difference is not small, join way faster, it can be seen in this JavaScript fast stitching string in the way in Java is also very suitable.

StringBuilder is the fastest, but its thread-safe problem, and only JDK5 support.

The "Go" Java 5 string concatenation method performance comparison.