[Java8]-String新特性-StringJoiner源码解析学习

---

主题列表：juejin, github, smartblue, cyanosis, channing-cyan, fancy, hydrogen, condensed-night-purple, greenwillow, v-green, vue-pro, healer-readable, mk-cute, jzman, geek-black, awesome-green, qklhk-chocolate

贡献主题：https://github.com/xitu/juejin-markdown-themes

theme: juejin
highlight:

java中新增了一个类StringJoin,可以对字符串进行自由的格式话，下面就进行介绍：

用于构造分隔的字符序列，使用分隔符，并且可以选择以提供的前缀开头，以提供的后缀结尾。

1. StringJoin源码解析

1.1属性

1. 字符串拼接的前缀，私有并且是 一旦赋值不可更改的String类型变量。
   private final String prefix;

2. 字符串拼接后缀，私有并且一旦赋值不可更改的String类型变量。
   private final String suffix;

3. 字符串拼接后缀，私有并且一旦赋值不可更改的String类型变量。
   private final String delimiter;

4. 私有的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());
    }

结果：

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);
    }

结果：

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);
    }

结果：