java中新增了一个类
StringJoin,可以对字符串进行自由的格式话，下面就进行介绍：
用于构造分隔的字符序列，使用分隔符，并且可以选择以提供的前缀开头，以提供的后缀结尾。
1. StringJoin源码解析
1.1属性
- 字符串拼接的前缀，私有并且是 一旦赋值不可更改的String类型变量。
` private final String prefix;`
- 字符串拼接后缀，私有并且一旦赋值不可更改的String类型变量。
private final String suffix; - 字符串拼接后缀，私有并且一旦赋值不可更改的String类型变量。
private final String delimiter; - 私有的StringBuilder实例。StringBuilder—在任何时候，由前缀构造的字符，添加的元素由分隔符分隔，但没有后缀，因此我们可以更容易地添加元素，而不必每次都修改后缀。
private StringBuilder value;
源码供上
public final class StringJoiner {
/** 前缀 */
private final String prefix;
/** 分隔符*/
`
private final String delimiter;`
/** 后缀*/
private final String suffix;
/*
*StringBuilder值——在任何时候，由前缀构造的字符，添加的元素由分隔符分隔，
*但没有后缀，因此我们可以更轻松地添加元素，而不必每次都移动后缀。
*/
private StringBuilder value;
/*
*默认情况下，由toString（）返回的prefix+suffix组成的字符串，
*或在尚未添加任何元素（即为空）时的value属性。
*用户可能会将其重写为其他值，包括空 字符串。
*/
private String emptyValue;
/**
* @param delimiter 分隔符
* @throws NullPointerException if {@code delimiter} is {@code null}
*/
public StringJoiner(CharSequence delimiter) {
this(delimiter, "", "");
}
/**
* @param delimiter 分隔符
* @param prefix 前缀
* @param suffix 后缀
* @throws 如果这些值设置为NUll 会抛出NullPointerException
*/
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;
}
/**
*Java 8中的StringJoiner类的方法设置字符序列。
*在确定此StringJoiner的字符串表示形式以及该字符串为空时，将使用这些字符。
*那将是没有添加任何元素。
*
* @param 空StringJoiner的值返回的字符
* @return this {@code StringJoiner} itself so the calls may be chained
* @throws NullPointerException when the {@code emptyValue} parameter is
* {@code null}
*/
public StringJoiner setEmptyValue(CharSequence emptyValue) {
this.emptyValue = Objects.requireNonNull(emptyValue,
"The empty value must not be null").toString();
return this;
}
/**StringBuilder转化为String了. */
@Override
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;
}
}
}
/**
*添加给定{@code CharSequence}值的副本作为{@code StringJoiner}值的下一个元素。 *如果{@code newElement}{@code null}，则添加{@code“null”}。
* @param newElement 添加的字符串
* @return 返回拼接的结果
*/
public StringJoiner add(CharSequence newElement) {
prepareBuilder().append(newElement);
return this;
}
/**
* Adds the contents of the given {@code StringJoiner} without prefix and
* suffix as the next element if it is non-empty. If the given {@code
* StringJoiner} is empty, the call has no effect.
*
* <p>A {@code StringJoiner} is empty if {@link #add(CharSequence) add()}
* has never been called, and if {@code merge()} has never been called
* with a non-empty {@code StringJoiner} argument.
*
* <p>If the other {@code StringJoiner} is using a different delimiter,
* then elements from the other {@code StringJoiner} are concatenated with
* that delimiter and the result is appended to this {@code StringJoiner}
* as a single element.
*
* @param other The {@code StringJoiner} whose contents should be merged
* into this one
* @throws NullPointerException if the other {@code StringJoiner} is null
* @return This {@code StringJoiner}
*/
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;
}
/**
* Returns the length of the {@code String} representation
* of this {@code StringJoiner}. Note that if
* no add methods have been called, then the length of the {@code String}
* representation (either {@code prefix + suffix} or {@code emptyValue})
* will be returned. The value should be equivalent to
* {@code toString().length()}.
*
* @return the length of the current value of {@code StringJoiner}
*/
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());
}
}
2.使用例子
2.1 分割添加
2.1.1方式一
public static void main(String[] args) {
// 添加元素方法
String delimiter = "!";
StringJoiner stringJoiner = new StringJoiner(delimiter);
stringJoiner.add("hi");
stringJoiner.add("newzhong");
System.out.println(stringJoiner.toString());
}
结果：
image
2.1.2方式二 使用Stream
public static void main(String[] args) {
List<String> stringList = new ArrayList<>(3);
stringList.add("a");
stringList.add("b");
stringList.add("c");
String collect = stringList.stream().collect(Collectors.joining("@"));
System.out.println(collect);
}
结果：
image
2.2.合并merge
public static void main(String[] args) {
StringJoiner stringJoiner1 = new StringJoiner("_");
stringJoiner1.add("1").add("2").add("3");
System.out.println("stringJoiner1:"+ stringJoiner1.toString());
StringJoiner stringJoiner2 = new StringJoiner("#");
stringJoiner2.add("4").add("5").add("6");
System.out.println("stringJoiner2:" + stringJoiner2.toString());
stringJoiner1.merge(stringJoiner2);
System.out.println("merge:" + stringJoiner1);
}
结果：
image
