字符串拼接还在用StringBuilder?快试试JDK8中的StringJoiner吧

前言

相信在开发过程中，我们经常会通过StringBuffer或者StingBuilder对字符串进行拼接，这个用法我们每个人并不陌生，但是你知道Java8中推出的StringJoiner吗？它比前者更加优美、灵活，如果你现在还使用StringBuffer拼接，强烈推荐你试试StringJoiner。

假设现在有个需求，打印1~10间的数，并用逗号隔开，[1,2,3,4,5,6,7,8,9,10]

首先我们用Stringbuilder来实现：

/**
 * @Author: chuxia0811
 * @Date: 2021/3/3 21:22
 * @Description :
 */
public class StringJoinerDemo1 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 1;i<=10;i++){
            sb.append(i);
            if (i!=10){
                sb.append(",");
            }
        }
        sb.append("]");
        System.out.println(sb.toString());
    }
}

打印结果如下：

[1,2,3,4,5,6,7,8,9,10]

下面我们用StringJoiner来实现：

/**
 * @Author: chuxia0811
 * @Date: 2021/3/3 21:09
 * @Description :
 */
public class StringJoinerDemo {
    public static void main(String[] args) {
        StringJoiner sj = new StringJoiner(",", "[", "]");
        for (int i = 1; i <= 10; i++) {
            sj.add(i + "");
        }
        System.out.println(sj.toString());
    }
}

运行结果如下：

[1,2,3,4,5,6,7,8,9,10]

可以看到，相同的拼接结果，StringJoiner要比StringBuilder简单很多，其实啊，StringJoiner在JDK1.8出来天生就是为了处理这类字符串拼接而生的，简化了很多繁琐的代码。下面我们来看下StringJoiner的源码：

public final class StringJoiner {
    private final String prefix;
    private final String delimiter;
    private final String suffix;
    private StringBuilder value;
    private String emptyValue;
    
    public StringJoiner(CharSequence delimiter) {
        this(delimiter, "", "");
    }

public StringJoiner(CharSequence delimiter,
                        CharSequence prefix,
                        CharSequence suffix) {
        Objects.requireNonNull(prefix, "The prefix must not be null");
        Objects.requireNonNull(delimiter, "The delimiter must not be null");
        Objects.requireNonNull(suffix, "The suffix must not be null");
        // make defensive copies of arguments
        this.prefix = prefix.toString();
        this.delimiter = delimiter.toString();
        this.suffix = suffix.toString();
        this.emptyValue = this.prefix + this.suffix;
    }

public StringJoiner setEmptyValue(CharSequence emptyValue) {
        this.emptyValue = Objects.requireNonNull(emptyValue,
            "The empty value must not be null").toString();
        return this;
    }
public String toString() {
        if (value == null) {
            return emptyValue;
        } else {
            if (suffix.equals("")) {
                return value.toString();
            } else {
                int initialLength = value.length();
                String result = value.append(suffix).toString();
                // reset value to pre-append initialLength
                value.setLength(initialLength);
                return result;
            }
        }
    }
public StringJoiner add(CharSequence newElement) {
        prepareBuilder().append(newElement);
        return this;
    }
public StringJoiner merge(StringJoiner other) {
        Objects.requireNonNull(other);
        if (other.value != null) {
            final int length = other.value.length();
            // lock the length so that we can seize the data to be appended
            // before initiate copying to avoid interference, especially when
            // merge 'this'
            StringBuilder builder = prepareBuilder();
            builder.append(other.value, other.prefix.length(), length);
        }
        return this;
    }

    private StringBuilder prepareBuilder() {
        if (value != null) {
            value.append(delimiter);
        } else {
            value = new StringBuilder().append(prefix);
        }
        return value;
    }
 public int length() {
        // Remember that we never actually append the suffix unless we return
        // the full (present) value or some sub-string or length of it, so that
        // we can add on more if we need to.
        return (value != null ? value.length() + suffix.length() :
                emptyValue.length());
    }
}

可以看到源码中重要的几个构造方法，无非就是有无prefix（前缀）,delimiter(分隔符),suffix(后缀),如果没有前后缀参数，则会调用this(delimiter, “”, “”);将前后缀置为空，merge（）方法即合并两个StringJoiner字符串：

public static void main(String[] args) {
        StringJoiner sj = new StringJoiner(",", "[", "]");
        StringJoiner sj1 = new StringJoiner(",", "[", "]");
        for (int i = 1; i <= 10; i++) {
            sj.add(i+"");
        }
        for (int i = 11; i <= 20; i++) {
            sj.add(i+"");
        }
        sj.merge(sj1);
        System.out.println(sj.toString());
    }

merge()后运行结果如下：

[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]

还要注意的是一个add(CharSequence newElement)方法，StringJoiner拼接元素不再是append()方法，二十add方法，其实方法底层还是append()方法：

 public StringJoiner add(CharSequence newElement) {
        prepareBuilder().append(newElement);
        return this;
    }

还有一个就是StringJoiner操作的数据类型都是CharSequence类型的，不知大家注意到了没有，其实：

CharSequence类是java.lang包下的一个接口，此接口对多种不同的对char访问的统一接口，像String、StringBuffer、StringBuilder类都是CharSequence的子接口；

CharSequence类和String类都可以定义字符串，但是String定义的字符串只能读，CharSequence定义的字符串是可读可写的。

所以这里可以理解为add()方法里可以是String,Stringbuffer,StringBuilder数据类型，都是ok的。