String类的三种常用拼接方法

1. “+” 连接符

我们都知道，String类是一个final的，不允许字符串的修改，更不允许字符串的“拼接”
使用“+” 连接符操作String类实际上是将String类转为StringBuilder类，调用StringBuilder类的append方法完成字符串拼接操作

反编译后源代码

String chenmo = "\u6C89\u9ED8"; // 沉默
String wanger = "\u738B\u4E8C"; // 王二
System.out.println((new StringBuilder(String.valueOf(chenmo))).append(wanger).toString());

StringBuilder类的append方法源码

@Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

StringBuilder类的父类是AbstractStringBuilder
创建一个count+len长度的数组，然后将原数组内容和拼接的内容拷贝到新数组中

 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;
    }
	private void ensureCapacityInternal(int minimumCapacity) {
        // overflow-conscious code
        if (minimumCapacity - value.length > 0) {
            value = Arrays.copyOf(value,
                    newCapacity(minimumCapacity));
        }
    }

注意：

在编译器是不会创建两个String类对象的，所以也不会存在将String类转为Stringbuilder类的情况存在

String str = "hello"+"world";

有关“+” 连接符类的注意事项：

 int a = 10;
 String b = "abc";
 //会将数值类型转化为字符串进行拼接
 System.out.println(a+b);  //10abc


String a = null;
String b = "abc";
//会将null对象转为“null”字符串进行拼接
System.out.println(a+b);  //nullabc

2. concat()方法

concat方法实际上是重新申请一个当前字符串长度+拼接字符串长度的字符数组，然后拼接好的字符串复制到新数组中，然后调用String类的构造方法创建一个新的数组
注意：concat方法可以链式编程

public String concat(String str) {
    if (str.isEmpty()) {
        return this;
    }
    int len = value.length;
    int otherLen = str.length();
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}

3. join方法
   join方法可以指定使用什么字符进行字符串的拼接

以下截取自涉及到join方法的StringJoiner类和StringBuilder类的多个方法
可以看到他实际上也是借助StringBuilder类的append()方法完成拼接

 
     * <blockquote>For example,
     * <pre>{@code
     *     String message = String.join("-", "Java", "is", "cool");
     *     // message returned is: "Java-is-cool"
     * }</pre></blockquote>
     * 
	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();
    }
    
    public StringJoiner(CharSequence delimiter) {
        this(delimiter, "", "");
    }
    
    public StringJoiner add(CharSequence newElement) {
        prepareBuilder().append(newElement);
        return this;
    }
    
    @Override
    public StringBuilder append(CharSequence s) {
        super.append(s);
        return this;
    }