简介
在JAVA开发过程中，经常会遇到字符串操作，对字符串的拼接操作更常见。
拼接字符串主要有以下几种方法:
1. "" + ""
2. "".concat("")
3. new StringBuilder().append()
4. new StringBuffer().append()
还有一个StringUtils工具类的join()方法，这里不做讨论。
时间紧迫的朋友可以跳过分析，直接看结论。
分析
1. 直接使用+拼接字符串
这是最方便的。但是它的性能在大部分情况下也是最低的一个。为什么这么说呢？请看官继续向下：
废话少说，先上个例子：
public class Test1 {
public static void main(String[] args) {
String s = "abc";
String s1 = "123" + s;
String s2 = "efg" + s1;
}
}
我们使用javap工具对字节码文件 Test1.class 反编译一下，瞅瞅+操作符干了些啥。
javap是java字节码反编译工具。-c 参数表示显示反汇编命令。
C:\com\demo> javap -c .\Test1.class
Compiled from "Test1.java"
public class com.demo.Test1 {
public com.demo.Test1();
Code:
0: aload_0
1: invokespecial #1                  // Method java/lang/Object."":()V
4: return
public static void main(java.lang.String[]);
Code:
0: ldc           #2                  // String abc
2: astore_1
3: new           #3                  // class java/lang/StringBuilder
6: dup
7: invokespecial #4                  // Method java/lang/StringBuilder."":()V
10: ldc           #5                  // String 123
12: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
15: aload_1
16: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
19: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
22: astore_2
23: new           #3                  // class java/lang/StringBuilder
26: dup
27: invokespecial #4                  // Method java/lang/StringBuilder."":()V
30: ldc           #8                  // String efg
32: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
35: aload_2
36: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
39: invokevirtual #7                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
42: astore_3
43: return
}
从反编译的代码中可以看出，编译器会把+符号优化成StringBuilder类，并使用 StringBuilder.append() 方法对字符拼接。最后调用 StringBuilder.toString() 方法，返回String。
在上面的代码中，我们对字符串进行了两次+操作，在优化后的代码也创建两次StringBuilder对象和调用两次toString()方法。
既然编译器会把+操作优化成StringBuilder方法，那它们效率会一样？其实不然。
2. 为什么+操作符比StringBuilder效率低？
首先看看StringBuilder怎么拼接字符串。
StringBuffer sb = new StringBuffer();
sb.append("abc");
sb.append("123");
sb.append("efg");
sb.toString();
上面的代码，只 new 了一个 StringBuilder 对象，而且只调用了一次 toString()方法。
我们知道在java中实例化对象，其实是很费时的，还要回收什么的。要不就不会搞出 单例模式 这种东西了。
而toString()这个方法更是浪费时间，我们来看下 StringBuilder 的 toString() 方法的源码。
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{
//省略 n 多代码
private transient char[] toStringCache;
@Override
public synchronized String toString() {
if (toStringCache == null) {
toStringCache = Arrays.copyOfRange(value, 0, count);
}
return new String(toStringCache, true);
}
//省略 n 多代码
}
StringBuilder和StringBuffer 都是 AbstractStringBuilder 的实现类，其底层是用 char[] 数组来储存数据的。StringBuilder默认初始char[]大小是16，当添加的字符大于16个，就会自动扩容。扩容这个操作本质是对数组的复制，也挺费时的，有兴趣的可以看一下源码。而+操作生成的StringBuilder默认大小为16，如果拼接的字符串过大，会频繁的扩容导致效率低下。
所以如果使用StringBuilder的时候，我们可以给一个参数capacity,初始化char[]的大小，这样可以避免频繁的扩容。
toString() 方法就是对 char[] 数组的复制。这可是个挺费时间的操作。
所以，虽然编译器对 + 操作进行了优化，但是由于频繁的实例化StringBuilder、频繁的调用toString()、在添加的字符串较大的情况下还会频繁的扩容，导致其效率极其低下。
但是，+一定比StringBuilder效率低嘛？答案当然是否定的。
3. +什么时候比StringBuilder高效？
我们再上两段代码：
public static void main(String[] args) {
// +
String s1 = "abc"+"123"+"efg";
// StringBuilder
StringBuilder sb = new StringBuilder();
String s2 = sb.append("abc").append("123").append("efg").toString();
}
同样把这段代码反编译一下，你知道，编译器把上面的代码编译成什么样了嘛？
public static void main(String[] args) {
String s1 = "abc123efg";
StringBuilder sb = new StringBuilder();
String s2 = sb.append("abc").append("123").append("efg").toString();
}
编译器直接在编译的时候就把 + 给组合完成了，运行时间为 0 。谁效率高谁效率低显而易见。
所以进行大量的字符串拼接操作 StringBuilder 更合适，而进行少量的，可预知的字符串拼接 + 更合适。(一般 for 循环中用 StringBuilder ，而静态变量等用 +)
4. StringBuilder与StringBuffer的区别。
它们两个的区别主要是 StringBuilder 是线程不安全的，而StringBuffer是线程不安全的。
我们看一下两个类的 append() 方法的源码：
StringBuilder
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{
// ...
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
// ...
}
StringBuffer
public final class StringBuffer extends AbstractStringBuilder implements java.io.Serializable, CharSequence{
// ...
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
// ...
}
StringBuilder比StringBuffer少了同步锁。其他基本相同，因为它们都是AbstractStringBuilder的实现类。是双胞胎(其实眼瞎的我莫名感觉他们的名字长得还蛮像的)
所以，在线程安全的情况下，StringBuilder更高效一点(毕竟同步锁也要花时间)，而线程不安全就只能用 StringBuffer。
5. String.concat()拼接与StringBuilder的比较
上代码：
String s = "abc".concat("123").concat("efg");
来瞅瞅源码：
public String concat(String str) {
int otherLen = str.length();
if (otherLen == 0) {
return this;
}
int len = value.length;
char buf[] = Arrays.copyOf(value, len + otherLen);
str.getChars(buf, len);
return new String(buf, true);
}
String.concat()方法调用了一次Arrays.copyOf(value, len + otherLen)方法，一次性分配了两个个字符串长度的内存空间，只执行了一次空间分配，并对拼接的两个字符各复制了一次，复制了两次。
而StringBuilder的append()在char[]未满的情况下，不会扩容。只会在初始化的时候执行一次空间分配，对两个字符串各复制了一次，复制了两次，但是最后会调用toString(),还会复制一次。
所以，比较之下，在只有两个字符串拼接的情况下，concat的效率要高一点，而大量的字符串拼接，StringBuilder效率会高一点，而且好在初始化的时候，指定char[]容器的大小，这样可以避免过度的扩容。
测试环境
系统：windows10 x64
处理器：i7 9700k
内存：16G
台式电脑
测试代码
public class Demo {
public static void main(String[] args) {
int number = 10000000; //拼接次数
long start ;           //开始时间
// concat
String s2 = "";
start = System.currentTimeMillis();
for(int i = 0 ; i < number ; ++i){
s2.concat(String.valueOf(i));
}
System.out.println(" concat 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");
// StringBuilder
StringBuilder stringBuilder = new StringBuilder();
start = System.currentTimeMillis();
for(int i = 0 ; i < number ; ++i){
stringBuilder.append(String.valueOf(i));
}
System.out.println("StringBuilder 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");
//StringBuffer
StringBuffer stringBuffer = new StringBuffer();
start = System.currentTimeMillis();
for(int i = 0 ; i < number ; ++i){
stringBuffer.append(String.valueOf(i));
}
System.out.println(" StringBuffer 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");
// +
String s = "";
start = System.currentTimeMillis();
for(int i = 0 ; i < number ; ++i){
s += String.valueOf(i);
}
System.out.println(" + 用时:"+ (System.currentTimeMillis() - start) + " 毫秒");
}
}
测试结果
测试结果取几次或者1次的平均值整数，不同运行环境会有偏差
+
concat
StringBuilder
StringBuffer
1000次
3ms
1ms
1ms
1ms
100000次
15584ms
10ms
6ms
6ms
1000000次
2212323ms
56ms
34ms
44ms
10000000次
很多很多ms
408ms
353ms
448ms
结论
+最好不要直接大量使用。只有在逻辑较简单的情况下(没有for循环之类)或者字符确定的情况下时候使用。如:String a = "abc"+"123"。
一般情况，在大量字符串拼接操作中。使用StringBuilder和StringBuffer，并尽可能的估算字符串的大小，使用带capacity参数的构造函数，也就是char[]的大小，这样可以避免重复的扩容。
StringBuffer 在线程不安全的情况下使用，其他情况一般使用StringBuilder。
只有两个字符串拼接的时候使用 concat(),这个性能最好。 但是每次拼接操作都会分配内存的操作，而上面两个并不一定每次拼接操作都会分配内存。

深刻感觉写程序就是在按照一定的规则在拼接字符串。
Java和JavaScript中的String具有不可变性(immutable)，同时正是这样的不可变性成为Java的线程安全和安全机制的基石。
Java和JavaScript对象都提供了丰富的方法，这里主要对比关于字符串链接的时间效率，比如：String str="abc"; str+="def"
关于Java的String连接性能讨论参见这篇博客：
Javascript的String对象提供了丰富的方法，但是由于String的不可变性，字符串发生改变的时候都会重新创建一个新的对象，使用“+”连接符来改变字符串同样是创建了新的字符串。
Array.join('')这个方法可以将数组中的对象转换为字符串。
下面通过自定义对象来实现JavaScript中的类似Java的StringBuffer对象。
实现：
/**
* StringBuffer对象
*/
function StringBuffer() {
this._stringbuffer_ = new Array();
/**
* 获取长度
*/
if (typeof StringBuffer.size == 'undefined') {
StringBuffer.prototype.size = function() {
return this.toString().length;
};
}
}
StringBuffer.prototype = new Object();
/**
* 转换为字符串
*/
StringBuffer.prototype.toString = function() {
return this._stringbuffer_.join('');
};
/**
* 追加字符串
*
* @param s
* @returns
*/
StringBuffer.prototype.append = function(s) {
if (typeof (s) == 'string') {
this._stringbuffer_.push(s);
} else if (typeof (s) == 'number') {
this._stringbuffer_.push(s.toString(10));
} else if (typeof (s) == 'boolean') {
this._stringbuffer_.push(s.toString());
} else {
;
}
return this.toString();
};
/**
* 获取指定位置的字符
*
* @param i
* @returns
*/
StringBuffer.prototype.charAt = function(i) {
var sb = this.toString();
if (i < 0 || i >= this.size()) {
return "";
} else {
return sb.charAt(i);
}
};
下面是对StringBuffer对象拼接字符串和“+”运算符拼接字符串的时间效率进行对比。
对比图一：
图标说明：String：指的是通过“+”运算符连接字符串
StringBuffer：指通过StringBuffer的append()方法连接字符串
图表的纵轴：指运算的时间，单位毫秒
图片的横轴：指连接字符串操作的次数
说明：上述链接的字符串都是单字符，精确度很低，仅仅作为时间效率的参考。
看到上面的图，不要惊讶，是不是和想像中的结果大相径庭，没错，这个结果的测试有问题的，相信自己，StringBuffer和"+"运算符连接字符串效率怎么会差距这么大呢？
下面是计算StringBuffer的时间：
start = new Date().getTime();
for ( var j = 0; j < range[i]; j++) {
sb.append(j);
}
sb.toString();
end = new Date().getTime();
sbTimes.push(end - start);
这样的计算机时间是有问题的，将字符串追加的时间也计算到时间效率中去了。
下面是修正后的时间效率对比的例子：
Insert title here
function calc() {
var ups=new Array(1000,2000,3000);
for ( var i = 0; i < ups.length; i++) {
draw(ups[i], "graphicDiv"+i);
}
}
function draw(up, name) {
//测试自定义StringBuffer和字符串拼接的效率
var sbTimes = new Array();
var stTimes = new Array();
var range = new Array();
for ( var i = 0; i < 20; i++) {
range[i] = 10000 +i* up;
}
for ( var i = 0; i < range.length; i++) {
StringBuffer
sb = new StringBuffer();
var start = new Date().getTime();
var st = "";
for ( var j = 0; j < range[i]; j++) {
st += j;
}
var end = new Date().getTime();
stTimes.push(end - start);
for ( var j = 0; j < range[i]; j++) {
sb.append(j);
}
start = new Date().getTime();
sb.toString();
end = new Date().getTime();
sbTimes.push(end - start);
sb = null;
}
StringBuffer
xml = new StringBuffer();
xml
.append('');
xml.append('');
for ( var i = 0; i < range.length; i++) {
xml.append(' ');
}
xml.append('');
xml
.append('');
for ( var i = 0; i < stTimes.length; i++) {
xml.append('');
}
xml.append('');
xml
.append('');
for ( var i = 0; i < sbTimes.length; i++) {
xml.append('');
}
xml.append('');
xml.append('');
var dataXml = xml.toString();
var fcf = new FusionCharts("FCF_MSArea2D.swf", "t_msa2d_" + up, 960,
680);
fcf.setDataXML(dataXml);
fcf.render(name);
}

                    
深刻感觉写程序就是在按照一定的规则在拼接字符串。
Java和JavaScript中的String具有不可变性(immutable)，同时正是这样的不可变性成为Java的线程安全和安全机制的基石。
Java和JavaScript对象都提供了丰富的方法，这里主要对比关于字符串链接的时间效率，比如：String str="abc"; str+="def"
关于Java的String连接性能讨论参见这篇博客：
http://www.blogjava.net/javagrass/archive/2010/01/24/310650.html


Javascript的String对象提供了丰富的方法，但是由于String的不可变性，字符串发生改变的时候都会重新创建一个新的对象，使用“+”连接符来改变字符串同样是创建了新的字符串。


Array.join('')这个方法可以将数组中的对象转换为字符串。
下面通过自定义对象来实现JavaScript中的类似Java的StringBuffer对象。
实现：




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53



/**

 * StringBuffer对象


 */


function StringBuffer() {


    this._stringbuffer_ = new Array();


    /**


     * 获取长度


     */


    if (typeof StringBuffer.size == 'undefined') {


        StringBuffer.prototype.size = function() {


            return this.toString().length;


        };


    }

}

StringBuffer.prototype = new Object();

/**

 * 转换为字符串


 */


StringBuffer.prototype.toString = function() {


    return this._stringbuffer_.join('');

};
/**

 * 追加字符串


 *


 * @param s


 * @returns


 */


StringBuffer.prototype.append = function(s) {


    if (typeof (s) == 'string') {


        this._stringbuffer_.push(s);


    } else if (typeof (s) == 'number') {


        this._stringbuffer_.push(s.toString(10));


    } else if (typeof (s) == 'boolean') {


        this._stringbuffer_.push(s.toString());


    } else {


        ;


    }


    return this.toString();

};
/**

 * 获取指定位置的字符


 *


 * @param i


 * @returns


 */


StringBuffer.prototype.charAt = function(i) {


    var sb = this.toString();


    if (i < 0 || i >= this.size()) {


        return "";


    } else {


        return sb.charAt(i);


    }

};




下面是对StringBuffer对象拼接字符串和“+”运算符拼接字符串的时间效率进行对比。
对比图一：



图标说明：

String：指的是通过“+”运算符连接字符串


StringBuffer：指通过StringBuffer的append()方法连接字符串


图表的纵轴：指运算的时间，单位毫秒


图片的横轴：指连接字符串操作的次数

说明：上述链接的字符串都是单字符，精确度很低，仅仅作为时间效率的参考。
看到上面的图，不要惊讶，是不是和想像中的结果大相径庭，没错，这个结果的测试有问题的，相信自己，StringBuffer和"+"运算符连接字符串效率怎么会差距这么大呢？
下面是计算StringBuffer的时间：





1
2
3
4
5
6
7




start = new Date().getTime();


for ( var j = 0; j < range[i]; j++) {


    sb.append(j);

}
sb.toString();

end = new Date().getTime();

sbTimes.push(end - start);






这样的计算机时间是有问题的，将字符串追加的时间也计算到时间效率中去了。
下面是修正后的时间效率对比的例子：





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76



<!DOCTYPE html>

<html>


<head>


<meta charset="UTF-8">


<title>Insert title here</title>


<script type="text/javascript" src="../js/jiUtil.js"></script>


<script type="text/javascript" src="../js/FusionCharts.js"></script>


<script type="text/javascript">


    function calc() {


        var ups=new Array(1000,2000,3000);


        for ( var i = 0; i < ups.length; i++) {


            draw(ups[i], "graphicDiv"+i);


        }


    }


    function draw(up, name) {


        //测试自定义StringBuffer和字符串拼接的效率


        var sbTimes = new Array();


        var stTimes = new Array();


        var range = new Array();


        for ( var i = 0; i < 20; i++) {


            range[i] = 10000 +i* up;


        }


        for ( var i = 0; i < range.length; i++) {


            StringBuffer


            sb = new StringBuffer();


            var start = new Date().getTime();


            var st = "";


            for ( var j = 0; j < range[i]; j++) {


                st += j;


            }


            var end = new Date().getTime();


            stTimes.push(end - start);


            for ( var j = 0; j < range[i]; j++) {


                sb.append(j);


            }


            start = new Date().getTime();


            sb.toString();


            end = new Date().getTime();


            sbTimes.push(end - start);


            sb = null;


        }


        StringBuffer


        xml = new StringBuffer();


        xml


                .append('<graph caption=" string vs join() on speed" subcaption="For the month of Oct 2013" divlinecolor="F47E00" numdivlines="4" showAreaBorder="1" areaBorderColor="000000"  showNames="1" numVDivLines="29" vDivLineAlpha="30" formatNumberScale="1" rotateNames="1">');


        xml.append('<categories  numberSuffix="ms">');


        for ( var i = 0; i < range.length; i++) {


            xml.append('<category name="'+range[i]+'" /> ');


        }


        xml.append('</categories>');


        xml


                .append('<dataset seriesname="String" color="FF5904" showValues="0" areaAlpha="50" showAreaBorder="1" areaBorderThickness="2" areaBorderColor="FF0000">');


        for ( var i = 0; i < stTimes.length; i++) {


            xml.append('<set value="'+stTimes[i]+'" />');


        }


        xml.append('</dataset>');


        xml


                .append('<dataset seriesname="StringBuffer" color="99cc99" showValues="0" areaAlpha="50" showAreaBorder="1" areaBorderThickness="2" areaBorderColor="006600">');


        for ( var i = 0; i < sbTimes.length; i++) {


            xml.append('<set value="'+sbTimes[i]+'" />');


        }


        xml.append('</dataset>');


        xml.append('</graph>');


        var dataXml = xml.toString();


        var fcf = new FusionCharts("FCF_MSArea2D.swf", "t_msa2d_" + up, 960,


                680);


        fcf.setDataXML(dataXml);


        fcf.render(name);


    }


</script>


</head>


<body     <div id="graphicDiv0" align="center"></div>


    <div id="graphicDiv1" align="center"></div>


    <div id="graphicDiv2" align="center"></div>


</body>


</html>





StringBuffer的append()实现使用了数组对象的push()方法,而数组的join()方法才是正真将数组中的字符串对象连接一起成为字符串，join()方法所花费的时间和“+”连接的时间在连接次数不够大的情况下相差并不是特别显著，相反还增加了append()这一操作。
如果站在空间复杂度看待这个问题，由于String的不可变性又会使得内存开销很大，产生较多的垃圾内存需要垃圾回收机制去处理。
对于浏览器和用户来讲，时间效率显得更重要些，用户交互需要更流畅，而不是去等待。
下面三张上述示例测试的结果图：





从上面看，StringBuffer完成的时间随链接数量变化不是特别大，而“+”连接在连接数量达到2万5千的时候开始网上飙升。
测试的影响因素：
本机的内存，浏览器JS引擎，其他操作对其部分运算的干扰（运算过程中进行其他事情占用计算机资源）。


总结：
1.实际工作做中几乎碰不到这样大的字符串连接；
2.“+”运算符连接字符串方便便捷，因为1，所以也不会产生太多的内存垃圾；
3.抛开数组中的元素添加，Array.join()方法连接字符串显然比“+”连接字符时间效率高很多；
4.实际工作用字符串连接也是有数据来源的，不可能无缘无故的拼接一些字符串，如上面的测试用例，就是要使用到一些数据，因而采用了append(）方法；
5.“+"连接字符串过程中产生的是匿名的字符串，二次使用较为困难，而使用append()方法连接字符串，由于其内部是使用Array进行存储的因此操作方便，而且便于修改，直接解决了String的不可变性带来的不便，同事内存空间是使用率很高。
6.使用StringBuffer去操作字符串比"+"连接字符串的代码可读性好，出错肯能性小，面向对象的意思更浓。
综上种种：使用StringBuffer对象的append()方法来拼接字符串更有利些。




本文转自 secondriver 51CTO博客，原文链接：http://blog.51cto.com/aiilive/1304174，如需转载请自行联系原作者


        
        
                
    

记录一下：java数组转字符串
以防止链接过期，做一下记录：例子是str[] = {0,1,2,3,4,5}
//第一种方法是遍历，将数组遍历后拆分再组合（这种就不讲了）
略...

//第二种，数组转字符串 org.apache.commons.lang3.StringUtils
String str1 = StringUtils.join(arr); // 数组转字符串,其实使用的也是遍历
System.out.println(str1); // 012345
String str2 = StringUtils.join(arr, ","); // 数组转字符串(逗号分隔)(推荐)
System.out.println(str2); // 0,1,2,3,4,5

//第三种，数组转字符串 org.apache.commons.lang3.ArrayUtils
String str3 = ArrayUtils.toString(arr, ","); // 数组转字符串(逗号分隔,首尾加大括号)
System.out.println(str3); // {0,1,2,3,4,5}

【参考】https://www.cnblogs.com/ooo0/p/9169311.html