上面有提到，字符串是不可变的，那么字符串的拼接又是怎么去拼接呢？其实这里讲的字符串的拼接就是将两个字符串拼成新的字符串，也就是最后一共三个字符串。
用 + 来拼接，多简单的事呀
这个应该算是最简单的一种方式了，但是很遗憾得玩告诉你，阿里巴巴在他们的规范里面之处不建议在 for 循环里面使用 “+” 进行字符串的拼接。这里的不建议，其实就是不允许的意思，只是人家说的比较委婉而已。事实上，现在还在拿 “+” 来做拼接的应该是比较少了吧。
我在逛阿里开发者社区的时候看到一篇文章《为什么阿里巴巴不建议在for循环中使用”+”进行字符串拼接》，里面提到这个 拼接符号 “+” 不是一个运算符重载，Java也并不支持这个所谓的运算符重载。作者提出这是 Java 的一个语法糖。
运算符重载：在计算机程序设计中，运算符重载(英语：operator overloading)是多态的一种。运算符重载，就是对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。
语法糖：语法糖(Syntactic sugar)，也译为糖衣语法，是由英国计算机科学家彼得·兰丁发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能没有影响，但是更方便程序员使用。语法糖让程序更加简洁，有更高的可读性。
concat
这是 String 里面提供的方法，用法如下：
String strA = "Hello" ;
String strB = "world" ;
String concat = strA.concat(",").concat(strB);
内部实现就是 将字符数组扩容后形成一个新的字符数组 buf , 再将参数 str 加进去。最后再将这个字符数组转成字符串。
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);
}
StringBuffer / StringBuilder
这两个应该可以说是一家的孪生兄弟了。做字符串拼接都是 append() 方法：
StringBuilder 里面的 append(String str) 的方法如下： 其实和 concat 方法差不多是吧。
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
// 这是 super.append()
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;
}
StringBuffer 里面的 append(String str)的方法如下：
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}
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 方法是一样的，唯一的不同就是 StringBuffer 是一个线程安全的拼接。我们可以看一下这两个的类的继承关系。
StringUtils.join
这个方法不是Java的，而是Apache的一个方法。方法在 apache.commons 里面。
StringUtils.join(strA, ",", strA)
这个方法最主要的功能是： 将数组或集合以某拼接符拼接到一起形成新的字符串。
String []list ={"hello","world"};
StringUtils.join(list, ",")
在Java 8 里面也有一个 join 方法：
String message = String.join("-", "Java", "is", "cool");
List strings = new LinkedList<>();
strings.add("Java");
strings.add("is");
strings.add("cool");
String message = String.join(" ", strings);
//message returned is: "Java is cool"
Set strings = new LinkedHashSet<>();
strings.add("Java");
strings.add("is");
strings.add("very");
strings.add("cool");
String message = String.join("-", strings);
//message returned is: "Java-is-very-cool"
Java8 中的新技能 StringJoiner
刚刚又说到 Java8 里面也有 join 方法，老夫查看第一个 join 方法，找到一个新的类。我们可以看下这个新的 类 StringJoiner.java
public static String join(CharSequence delimiter, CharSequence... elements) {
Objects.requireNonNull(delimiter);
Objects.requireNonNull(elements);
// Number of elements not likely worth Arrays.stream overhead.
StringJoiner joiner = new StringJoiner(delimiter);
for (CharSequence cs: elements) {
joiner.add(cs);
}
return joiner.toString();
}
当我们StringJoiner(CharSequence delimiter)初始化一个StringJoiner的时候，这个delimiter其实是分隔符，并不是可变字符串的初始值。
我们看到这个 joiner.add(cs) ,然后又做了 一个 joiner.toString() . 是不是很像我们的StringBuilder 里面的 append 方法 ? 我们进去看下这个方法。
public StringJoiner add(CharSequence newElement) {
prepareBuilder().append(newElement);
return this;
}
现在是不是和 StringBuilder 很像？我们再来看这个 prepareBuilder() 是个啥玩意
private StringBuilder prepareBuilder() {
if (value != null) {
value.append(delimiter);
} else {
value = new StringBuilder().append(prefix);
}
return value;
}
我们看到了，其实他就是一个StringBuilder. 那么他的性能就应当和我们的StringBuilder 不相上下。
在 Java 8 中 引入了这个 StringJoiner , 自然不是平白无故的引入。Java中，我们看到了许多新鲜元素，比如说 Stream .
举个例子：
现在有一个 集合 :
List list = ImmutableList.of("Java" , "is" , "the" , "best" , "language");
现在，我需要的形式是这个：
Java is the best language
+
想要用 + ， 那就要遍历，肯定是循环加 “+” ， 那我们就直接 pass 了。
concat
String str = "" ;
for (int i = 0; i < list.size(); i++) {
str = str.concat(" ").concat(list.get(i)) ;
}
StringBuilder
StringBuilder sb = new StringBuilder() ;
for (int i = 0; i < list.size(); i++) {
sb.append(list.get(i)).append(" ") ;
}
也可以这么写：
String result = list.stream().reduce(new StringBuilder(), (sb, str) -> sb.append(str).append(" "), StringBuilder::append).get();
当然，这里要是不想用 StringBuilder , 就可以换成 + , 看起来也简单
String result = list.stream().reduce((a,b)->a+" "+b).get();
StringJoiner
以上的方法，其实很常见，也很简单，现在看看这个怎么用：
String result = list.stream().collect(Collectors.joining(" "));
就这样。这里的实现如下：
public static Collector joining(CharSequence delimiter) {
return joining(delimiter, "", "");
}
public static Collector joining(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix) {
return new CollectorImpl<>(
() -> new StringJoiner(delimiter, prefix, suffix),
StringJoiner::add, StringJoiner::merge,
StringJoiner::toString, CH_NOID);
}
总结
现在问题来了，以上的这么多方法都好用，怎么选？
不涉及循环的，就是那种很简单的那种拼接，就用 + ，简单方便 ；
涉及到循环的，比如说 for 的，可以考虑使用 StringBuilder , 要求线程安全的就选择 StringBuffer ;
有 List 这种的，StringJoiner 不免一个好的选择。
concat 就看你心情了，不想用 + 就用他吧。
其实呢，在字符串额度拼接里面，老夫还用过这两个，应该是用的比较多的：
String java = String.format("%s is the beat language", "Java");
MessageFormat.format("{0} is the beat language" , "Java") ;
MessageFormat 方法在 java.text 里面，所以呢，他对一些 文本类数据(String)比较友好。曾经在使用这个方法的时候， 我有一个数字，20 000 000 的一个数，经过这个类转成了 20,,000,000 。 而用 String.format() 就没这个问题。具体的看大家选择。这两种方式其实并不能称之为字符串的拼接，顶多就是字符串的格式化。 format 方法不就是格式化额度意思吗。