开发笔记:拼接字符串新姿势—StringJoiner

前言

你知道使用原生 JDK 拼接字符串有多少种玩法吗&＃xff1f;我们能想到的大概就是StringBuilder、StringBuffer、 String.concat、还有用 &＃43; 拼接。还有其他的吗&＃xff1f;接下来就来讲讲 Java 8 里面新增了一个拼接字符串的类 &＃xff0c;叫 StringJoiner 的用法。

概述

StringJoiner 是 java.util 包中的一个类&＃xff0c;用于构造一个由分隔符分隔的字符串&＃xff0c;并且可以从提供的前缀字符串开头&＃xff0c;以提供的后缀字符串结尾。虽然这些功能&＃xff0c;我们可以使用 StringBuilder 或者 StringBuffer 来实现的&＃xff0c; 但是 StringJoiner 提供的方法更简单&＃xff0c;而且也不需要写大量的代码就能成。

构造函数

StringJoiner 一共有 2 个构造函数。 构造函数很简单&＃xff0c;就是对 分隔符&＃xff0c;前缀和后缀字符串的初始化。

public StringJoiner(CharSequence delimiter) {
this(delimiter, "", "");//默认前缀和后缀为"",重载调用
}
public StringJoiner(CharSequence delimiter,
CharSequence prefix,
CharSequence suffix) {
//间隔符&＃xff0c;前缀和后缀判断是否为null&＃xff0c;null将抛出异常
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");
//成员变量赋值
this.prefix &＃61; prefix.toString();
this.delimiter &＃61; delimiter.toString();
this.suffix &＃61; suffix.toString();
//空值被设置为只有前后缀
this.emptyValue &＃61; this.prefix &＃43; this.suffix;
}


用法

StringJoiner 的用法其实很简单&＃xff0c;来&＃xff0c;我们看一下 StringJoiner 字符串拼接的用法。

public class StringJoinerTest {
public static void main(String[] args) {
StringJoiner sj &＃61; new StringJoiner("hello");
sj.add("Java 8 ");
sj.add("Java 11");
System.out.println(sj.toString());
StringJoiner sj1 &＃61; new StringJoiner(":","[","]");
sj1.add("Java8").add("Java11").add("Java15");
System.out.println(sj1.toString());
}
}


输出结果&＃xff1a;

Java 8 helloJava 11
[Java8:Java11:Java15]


注意&＃xff1a;

1. 当我们使用StringJoiner(CharSequence delimiter)初始化一个StringJoiner的时候&＃xff0c;这个delimiter其实是分隔符&＃xff0c;并不是字符串的初始值。
2. StringJoiner(CharSequence delimiter,CharSequence prefix,CharSequence suffix)的第二个和第三个参数分别是拼接后的字符串的前缀和后缀。

源码分析

JDK8中源码

public StringJoiner setEmptyValue(CharSequence emptyValue) {
this.emptyValue &＃61; Objects.requireNonNull(emptyValue,
"The empty value must not be null").toString();
return this;
}
&＃64;Override
public String toString() {
if (value &＃61;&＃61; null) {
return emptyValue;
} else {
if (suffix.equals("")) {
return value.toString();
} else {
int initialLength &＃61; value.length();
String result &＃61; value.append(suffix).toString();
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 !&＃61; null) {
final int length &＃61; other.value.length();
StringBuilder builder &＃61; prepareBuilder();
builder.append(other.value, other.prefix.length(), length);
}
return this;
}
private StringBuilder prepareBuilder() {
if (value !&＃61; null) {
value.append(delimiter);
} else {
value &＃61; new StringBuilder().append(prefix);
}
return value;
}
public int length() {
return (value !&＃61; null ? value.length() &＃43; suffix.length() :
emptyValue.length());
}


JDK11中源码

public final class StringJoiner {
private String[] elts;
&＃64;Override
public String toString() {
final String[] elts &＃61; this.elts;
if (elts &＃61;&＃61; null && emptyValue !&＃61; null) {
return emptyValue;
}
final int size &＃61; this.size;
final int addLen &＃61; prefix.length() &＃43; suffix.length();
if (addLen &＃61;&＃61; 0) {
compactElts();
return size &＃61;&＃61; 0 ? "" : elts[0];
}
final String delimiter &＃61; this.delimiter;
final char[] chars &＃61; new char[len &＃43; addLen];
int k &＃61; getChars(prefix, chars, 0);
if (size > 0) {
k &＃43;&＃61; getChars(elts[0], chars, k);
for (int i &＃61; 1; i k &＃43;&＃61; getChars(delimiter, chars, k);
k &＃43;&＃61; getChars(elts[i], chars, k);
}
}
k &＃43;&＃61; getChars(suffix, chars, k);
return new String(chars);
}
public StringJoiner add(CharSequence newElement) {
final String elt &＃61; String.valueOf(newElement);
if (elts &＃61;&＃61; null) {
elts &＃61; new String[8];
} else {
if (size &＃61;&＃61; elts.length)
elts &＃61; Arrays.copyOf(elts, 2 * size);
len &＃43;&＃61; delimiter.length();
}
len &＃43;&＃61; elt.length();
elts[size&＃43;&＃43;] &＃61; elt;
return this;
}
}


比较一下JDK8和JDK11中StringJoiner的源码add 方法的实现&＃xff1a;

1. JDK8中StringJoiner 是通过 StringBuilder 来实现的&＃xff1b;

2. JDK11中StringJoiner 就是把待拼接的字符串&＃xff0c;放到一个字符串数组里面&＃xff0c;toString() 方法的时候&＃xff0c;才是真正做字符串拼接的过程。

那么问题来了&＃xff0c;既然 JDK 8 的时候&＃xff0c;已经使用了StringBuilder 来实现&＃xff0c;JDK11为什么还要改成 String[] 来缓存所有的待拼接的字符串。这个就要涉及到JVM底层的优化了。

既然已经有了StringBuilder&＃xff0c;为什么还要造一个StringJoiner&＃xff0c;它的优势到底在哪里&＃xff0c;那我们再来找找原因&＃xff0c;我们可以看到代码的注释块中&＃xff0c;标记了 Collectors#joining 。

我们看看 Collectors#joining 究竟做了什么呢&＃xff1f;

public static Collector joining() {
return new CollectorImpl(
StringBuilder::new, StringBuilder::append,
(r1, r2) -> { r1.append(r2); return r1; },
StringBuilder::toString, CH_NOID);
}
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);
}


原来 Java 8 中Stream 是借助了 StringJoiner 来实现的。 这个时候&＃xff0c;我们可能会想&＃xff0c;为什么不使用 StringBuilder 来实现呢&＃xff1f; 我们可以从示例里看出&＃xff0c;如果 StringBuilder 来构造拼接的话&＃xff0c;在没有前后缀的情况下&＃xff0c;应该还是简单的&＃xff0c;但是一旦到需要其他前后缀的拼接&＃xff0c;那这个就变得很复杂啦。

所以 StringJoiner 在 Java 8 的地位是 StringBuilder 所不能代替的。

总结

本文介绍了 Java 8 开始提供的字符串拼接类 StringJoiner。 JDK 8 中 StringJoiner 是通过 StringBuilder 实现的&＃xff0c; 所以它的性能和StringBuilder 差不多&＃xff0c;它也是非线程安全的。JDK 11 中已经对其进行了优化&＃xff0c;通过 String[] 来代理 StringBuilder 。

在日常的开发过程中&＃xff0c;我们怎么选择字符串拼接类呢&＃xff1f;

1. 简单的字符串拼接&＃xff0c;直接使用 &＃43; 即可。
2. 在 for 循环之类的场景下需要字符串拼接&＃xff0c;可以优先考虑使用 StringBuilder 。
3. 在使用 Java Stream 和 lambda 的场景下需要字符串拼接&＃xff0c;可以优先考虑使用 StringJoiner。

作为阅读福利我也整理了一些Java学习笔记&＃43;面试真题&＃xff0c;现在免费分享给阅读到本篇文章的Java程序员朋友们&＃xff0c;需要的点击下面链接领取&＃xff01;&＃xff01;

最全学习笔记大厂真题&＃43;微服务&＃43;MySQL&＃43;分布式&＃43;SSM框架&＃43;Java&＃43;Redis&＃43;数据结构与算法&＃43;网络&＃43;Linux&＃43;Spring全家桶&＃43;JVM&＃43;高并发&＃43;各大学习思维脑图&＃43;面试集合