为什么不建议在for循环中使用"+"进行字符串拼接

本文是对于Java字符串相关知识的一个补充,主要介绍字符串拼接相关的知识。基于JDK1.8_201。

字符串拼接

字符串拼接是在Java代码中经常要做的事情,我们都知道String是Java中一个不可变的类,一旦被实例化就无法被修改。但是既然字符串是不可变的,那么是如何进行字符串拼接呢?

字符串不变性与字符串拼接

其实所有的所谓字符串拼接,都是重新生成了一个新的字符串。比如以下代码:

1
2
String str = "abcd";
s = s.concat("ef");

其实最后得到的s已经是一个新的字符串了,如下图。

s指向的是重新创建出来的String对象。

那么在Java中如何进行字符串拼接呢?

使用“+”拼接字符串

在Java中,拼接字符串最简单的方式就是直接使用符号“+”来拼接,如:

1
2
3
String str1 = "Hello";
String str2 = "World";
String str3 = str1 + str2;

这里要特别说明一点,有人把Java中使用+拼接字符串的功能理解为运算符重载。其实并不是,Java是不支持运算符重载的。这其实只是Java提供的一个语法糖

concat

除了使用“+”拼接字符串之外,还可以使用String类中的方法concat方法来拼接字符串。如:

1
2
3
String str1 = "Hello";
String str2 = "World";
String str3 = str1.concat(str2);

StringBuffer

关于字符串,Java中除了定义了一个可以用来定义字符串常量String类以外,还提供了可以用来定义字符串变量StringBuffer类,它的对象是可以扩充和修改的。

使用StringBuffer可以方便的对字符串进行拼接。如:

1
2
3
StringBuffer str1 = new StringBuffer("Hello");
String str2 = "World";
StringBuffer str3 = str1.append(str2);

StringBuilder

除了StringBuffer以外,还有一个类StringBuilder也可以使用,其用法和StringBuffer类似。如

1
2
3
StringBuilder str1 = new StringBuilder("Hello");
String str2 = "World";
StringBuilder str3 = str1.append(str2);

StringUtils.join

除了JDK中内置的字符串拼接方法,还可以使用一些开源类库中提供的字符串拼接方法名,如apache.commons中提供的StringUtils类,其中的join方法可以拼接字符串。

1
2
3
String str1 = "Hello";
String str2 = "World";
System.out.println(StringUtils.join(str1, ",", str2));

StringUtils中提供的join方法,最主要的功能是:将数组或集合以某拼接符拼接到一起形成新的字符串,如:

1
2
3
4
String []list  ={"Hello","My name is Chen"};
String result= StringUtils.join(list,",");
System.out.println(result);
// 结果:Hello,My name is Chen

以上就是比较常用的五种在Java种拼接字符串的方式,那么到底哪种更好用呢?为什么阿里巴巴Java开发手册中不建议在循环体中使用+进行字符串拼接呢?

使用‘+‘拼接字符串的实现原理

前面提到过,使用+拼接字符串,其实只是Java提供的一个语法糖, 那么,我们就来解一解这个语法糖,看看他的内部原理到底是如何实现的。

还是这样一段代码。我们把他生成的字节码进行反编译,看看结果。

1
2
3
String str1 = "Hello";
String str2 = "World";
String str3 = str1 + "," + str2;

反编译后的内容如下,反编译工具为jad。

1
2
3
String str1 = "Hollis";
String str2 = "World";
String str3 = (new StringBuilder()).append(str1).append(",").append(str2).toString();

通过查看反编译以后的代码,我们可以发现,原来字符串常量在拼接过程中,是将String转成了StringBuilder后,使用其append方法进行处理的。

那么也就是说,Java中的+对字符串的拼接,其实现原理是使用StringBuilder.append

concat是如何实现的

我们再来看一下concat方法的源代码,看一下这个方法又是如何实现的。

1
2
3
4
5
6
7
8
9
10
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方法,其实是new了一个新的String,这也就呼应到前面我们说的字符串的不变性问题上了。

StringBuffer和StringBuilder

接下来我们看看StringBufferStringBuilder的实现原理。

String类类似,StringBuilder类也封装了一个字符数组,定义如下:

1
char[] value;

String不同的是,它并不是final的,所以他是可以修改的。另外,与String不同,字符数组中不一定所有位置都已经被使用,它有一个实例变量,表示数组中已经使用的字符个数,定义如下:

1
int count;

其append源码如下:

1
2
3
4
public StringBuilder append(String str) {
super.append(str);
return this;
}

该类继承了AbstractStringBuilder类,看下其append方法:

1
2
3
4
5
6
7
8
9
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}

append会直接拷贝字符到内部的字符数组中,如果字符数组长度不够,会进行扩展。

StringBufferStringBuilder类似,最大的区别就是StringBuffer是线程安全的,看一下StringBufferappend方法。

1
2
3
4
5
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}

该方法使用synchronized进行声明,说明是一个线程安全的方法。而StringBuilder则不是线程安全的。

StringUtils.join是如何实现的

通过查看StringUtils.join的源代码,我们可以发现,其实他也是通过StringBuilder来实现的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static String join(final double[] array, final char separator, final int startIndex, final int endIndex) {
if (array == null) {
return null;
}
final int noOfItems = endIndex - startIndex;
if (noOfItems <= 0) {
return EMPTY;
}
final StringBuilder buf = new StringBuilder(noOfItems * 16);
for (int i = startIndex; i < endIndex; i++) {
if (i > startIndex) {
buf.append(separator);
}
buf.append(array[i]);
}
return buf.toString();
}

效率比较

既然有这么多种字符串拼接的方法,那么到底哪一种效率最高呢?我们来简单对比一下。

1
2
3
4
5
6
7
long t1 = System.currentTimeMillis();
//这里是初始字符串定义
for (int i = 0; i &lt; 50000; i++) {
//这里是字符串拼接代码
}
long t2 = System.currentTimeMillis();
System.out.println("cost:" + (t2 - t1));

我们使用形如以上形式的代码,分别测试下五种字符串拼接代码的运行时间。得到结果如下:

1
2
3
4
5
+ cost:5119
StringBuilder cost:3
StringBuffer cost:4
concat cost:3623
StringUtils.join cost:25726

从结果可以看出,用时从短到长的对比是:

1
StringBuilder < StringBuffer < concat < + < StringUtils.join

StringBufferStringBuilder的基础上,做了同步处理,所以在耗时上会相对多一些,这个很好理解。

StringUtils.join也是使用了StringBuilder,并且其中还是有很多其他操作,所以耗时较长,这个也容易理解。其实StringUtils.join更擅长处理字符串数组或者列表的拼接。

那么问题来了,前面我们分析过,其实使用+拼接字符串的实现原理也是使用的StringBuilder,那为什么结果相差这么多,高达1000多倍呢?

我们再把以下代码反编译下:

1
2
3
4
5
6
7
8
long t1 = System.currentTimeMillis();
String str = "hollis";
for (int i = 0; i &lt; 50000; i++) {
String s = String.valueOf(i);
str += s;
}
long t2 = System.currentTimeMillis();
System.out.println("+ cost:" + (t2 - t1));

反编译后代码如下:

1
2
3
4
5
6
7
8
9
10
long t1 = System.currentTimeMillis();
String str = "hollis";
for(int i = 0; i &lt; 50000; i++)
{
String s = String.valueOf(i);
str = (new StringBuilder()).append(str).append(s).toString();
}

long t2 = System.currentTimeMillis();
System.out.println((new StringBuilder()).append("+ cost:").append(t2 - t1).toString());

我们可以看到,反编译后的代码,在for循环中,每次都是new了一个StringBuilder,然后再把String转成StringBuilder,再进行append

而频繁的新建对象当然要耗费很多时间了,不仅仅会耗费时间,频繁的创建对象,还会造成内存资源的浪费。

所以,阿里巴巴Java开发手册建议:循环体内,字符串的连接方式,使用 StringBuilderappend 方法进行扩展。而不要使用+

总结

常用的字符串拼接方式有五种,分别是使用+、使用concat、使用StringBuilder、使用StringBuffer以及使用StringUtils.join

由于字符串拼接过程中会创建新的对象,所以如果要在一个循环体中进行字符串拼接,就要考虑内存问题和效率问题。

因此,经过对比,我们发现,直接使用StringBuilder的方式是效率最高的。因为StringBuilder天生就是设计来定义可变字符串和字符串的变化操作的。

但是,还要强调的是:

1、如果不是在循环体中进行字符串拼接的话,直接使用+就好了。

2、如果在并发场景中进行字符串拼接的话,要使用StringBuffer来代替StringBuilder

您的支持将让服务器运行更长久