StringJoiner 源码阅读

StringJoiner

• 属性说明

/**
 *  StringJoiner 使用指定的分割符将多个字符串进行拼接，并可指定前缀和后缀
 *
 * @see java.util.stream.Collectors#joining(CharSequence)
 * @see java.util.stream.Collectors#joining(CharSequence, CharSequence, CharSequence)
 * @since  1.8
 */
public final class StringJoiner {
    /**
     *  前缀
     */
    private final String prefix;

    /**
     *  分割符
     */
    private final String delimiter;

    /**
     *  后缀
     */
    private final String suffix;

    /** 持续添加的字符串数组 */
    private String[] elts;

    /** 已添加的字符串个数 */
    private int size;

    /** 所有字符串的总长度，包括前缀和后缀 */
    private int len;

    /**
     *  空值
     *
     * When null, prefix + suffix is used as the empty value.
     */
    private String emptyValue;

• 实例化

    /**
     *  创建分割符为 delimiter，前缀和后缀都为 "" 的 StringJoiner 对象
     *
     * @param  delimiter    分割符
     */
    public StringJoiner(CharSequence delimiter) {
        this(delimiter, "", "");
    }

    /**
     *  创建指定分割符、前缀、后缀的 StringJoiner
     *
     * @param  delimiter    用于连接字符串的分隔符
     * @param  prefix   前缀字符序列
     * @param  suffix   后缀字符序列
     */
    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();
    }

• 追加字符串

    /**
     *  追加字符串 newElement 到此 StringJoiner 中
     *
     * @param  newElement   追加的新元素
     */
    public StringJoiner add(CharSequence newElement) {
        final String elt = String.valueOf(newElement);
        // 1）创建长度为 8 的初始缓冲区
        if (elts == null) {
            elts = new String[8];
        } else {
            // 如果已满，则执行双倍扩容
            if (size == elts.length) {
                elts = Arrays.copyOf(elts, 2 * size);
            }
            // 记录总字符数
            len += delimiter.length();
        }
        // 记录总字符数
        len += elt.length();
        // 写入目标元素
        elts[size++] = elt;
        return this;
    }

• 返回此 StringJoiner 的字符串表示

    /**
     *  返回此 StringJoiner 的字符串表示
     */
    @Override
    public String toString() {
        final String[] elts = this.elts;
        // 1）尝试返回空值
        if (elts == null && emptyValue != null) {
            return emptyValue;
        }
        final int size = this.size;
        final int addLen = prefix.length() + suffix.length();
        // 如果未指定前缀和后缀
        if (addLen == 0) {
            // 完成字符串拼接
            compactElts();
            return size == 0 ? "" : elts[0];
        }
        final String delimiter = this.delimiter;
        final char[] chars = new char[len + addLen];
        int k = getChars(prefix, chars, 0);
        if (size > 0) {
            k += getChars(elts[0], chars, k);
            for (int i = 1; i < size; i++) {
                k += getChars(delimiter, chars, k);
                k += getChars(elts[i], chars, k);
            }
        }
        k += getChars(suffix, chars, k);
        return new String(chars);
    }

    private void compactElts() {
        // 完成字符串拼接
        if (size > 1) {
            final char[] chars = new char[len];
            // 写入第一个字符串
            int i = 1, k = getChars(elts[0], chars, 0);
            do {
                // 写入分割符
                k += getChars(delimiter, chars, k);
                // 写入后一个字符串
                k += getChars(elts[i], chars, k);
                elts[i] = null;
            } while (++i < size);
            size = 1;
            elts[0] = new String(chars);
        }
    }