# 关于Java里面的字符串拼接，你了解多少？
### 前言
字符串拼接是我们日常开发中很常见的操作，虽然常见，但要是使用不当的的话，很有可能让你的程序处理效率降低一大半，所以我们有必要来重新了解一下Java里面的字符串操作。
### 基础知识回顾
（1）关于字符串字面量
class="java" name="code">```
String text="我是攻城师1";
```
上面的这行代码是我们最常见的声明方式，它会创建一个对象，并放在字符串常量池里面，关于常量池的内容，可以参考我之前的文章。
（2）关于new String
```
String text2=new String("我是攻城师2")
```
上面的这段代码是通过new的方式来创建字符串对象的，这里总共会产生2个对象，第一个是new创建的在堆
内存里，第二个是字面量创建的在常量池里面。此外text2变量是在
线程的栈里面，它只引用了堆里面的对象实例，这一点需要注意很多新手分不清楚
他们之间的联系。
（3）关于String不可变性
Java的里面String类的有关操作，都会生成新的String实例，所以在大量修改操作时，应该使用可变的StringBuffer或者StringBuilder。
### 字符串拼接的几种方法
（1）使用 + 号
（2）使用字符串的concat方法
（3）StringBuffer的append方法
（4）StringBuilder的append方法
上面的四种就是Java里面所有的关于字符串拼接的方法，问题来了
四种方法之间有什么区别？
* StringBuffer是
线程安全的，StringBuilder是线程不安全的，大部分时候应该首选StringBuilder方法，它的字符串拼接效率最高，因为不会创建很多的String实例。
* +号与concat方法的：
首先+号是可以和各种类型拼接字符串的，而concat的参数必须是字符串类型，其次concat方法拼接null值是会抛空指针的，代码如下：
```
//DIFFERENCE 1
String a = null;
String b = "foo";
String c = a + b; // c = nullfoo
String d = b.concat(a); // 空指针
String e = a.concat(b); // 空指针
//DIFFERENCE 2
String x = "1" + 2; // x = 12
String y = "1".concat(2); // 编译错误
```
最后，他们在底层处理机制上也不同：
```
String c ="a" + "b";
```
上面的语句在编译的时候会转化成下面的代码：
```
c = new StringBuilder()
.append("a")
.append("b")
.toString();
```
注意上面的代码会涉及三次的new char[]数组分配和数组拷贝动作。
而同样的操作使用concat方法，则只会涉及一次的数组分组和数组拷贝：
```
String c=”a“.concat("b")
```
源码如下：
```
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);
}
```
### 字符串拼接的性能对比
下面我们分别对上面的四种方法在jdk8的mac系统上，进行1万次的拼接动作，看下性能表现，测试代码如下：
```
final int loop_count=10000;
// 1 +
String s1="s1";
long startTime=System.nanoTime();
for (int i = 0; i < loop_count; i++) {
s1=s1+Integer.toString(i);
}
long duration=System.nanoTime()-startTime;
System.out.println(" + cost: "+duration/1000+" 微秒 ");
// 2 concat
String s2="s2";
startTime=System.nanoTime();
for (int i = 0; i < loop_count; i++) {
s2=s2.concat(Integer.toString(i));
}
duration=System.nanoTime()-startTime;
System.out.println(" concat cost: "+duration/1000+" 微秒 ");
// 3 stringbuffer
StringBuffer s3=new StringBuffer("s3");
startTime=System.nanoTime();
for (int i = 0; i < loop_count; i++) {
s3.append(Integer.toString(i));
}
duration=System.nanoTime()-startTime;
System.out.println(" StringBuffer cost: "+duration/1000+" 微秒 ");
// 4 stringbuilder
StringBuilder s4=new StringBuilder("s4");
startTime=System.nanoTime();
for (int i = 0; i < loop_count; i++) {
s4.append(Integer.toString(i));
}
duration=System.nanoTime()-startTime;
System.out.println(" StringBuilder cost: "+duration/1000+" 微秒 ");
```
结果输出如下：
```
+ cost: 432673 微秒
concat cost: 49118 微秒
StringBuffer cost: 1011 微秒
StringBuilder cost: 734 微秒
```
从上面的
循环1万次拼接的结果来看+
caozuofu.html" target="_blank">操作符在循环loop中拼接字符串最耗时，前两个结果与后两个结果完全不在一个量级上，因为前面的两种方法在每次循环时候都会生成一个新的String实例返回，而后面的两个则只需要最后使用一次，至于StringBuffer比StringBuilder耗时是因为前者是
同步的方法，后者则不是。
### 总结
（1）在没有线程问题的情况下大量修改字符串优先考虑StringBuilder
（2）在有线程问题的情况下大量修改字符串优先考虑StringBuffer
（3）如果仅仅是两个字符串的拼接优先考虑String类的concat方法
（4）如果一次性拼接多个字符串，可以考虑使用非循环模式下的+号拼接
或者直接使用StringBuilder对象。
（5）最后还有一个不常用的方法String.join其内部用的是StringBuilder类，所以不再多说。
相关文章
