Performance Comparison of Java five String concatenation methods.

Recently I wrote a plug-in that may consider String concatenation. I thought about several methods, but the performance was unknown. So I used JUnit to write a unit test.

 

The Code is as follows:

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 = 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. }

 

The running result is 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 16 MS
11:00:22, 968 info teststring: 58-stringbuffer cost 31 MS
11:00:23, 031 info teststring: 70-stringbuilder cost 63 MS

 

Note:

The number of stringbuilder loops is 10 times the number of other loops. If the number is the same, 0 is returned, which shows that stringbuilder is faster.

 

Summary:

The efficiency of using + is the worst. Because Concat is implemented by internal mechanisms, it is much better than the + method.

Join and stringbuffer are not much different. The join method is faster. It can be seen that this method of rapid String concatenation in Javascript is also very suitable in Java.

Stringbuilder has the fastest speed, but it has thread security issues and is only supported by jdk5.