【JAVA留档】可迭代对象字符串构建器

可迭代对象字符串构建器（可迭代对象常见有List、Set等），用于可迭代对象转为字符串的细节定义，如前缀、后缀、间隔符等。

package com.kovizone.util;

import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Setter;
import lombok.experimental.Accessors;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import java.util.function.Function;
import java.util.function.Predicate;

/**
 * 可迭代对象字符串构建器
 *
 * @author KV
 * @since 2023/01/13
 */
@Setter
@Accessors(chain = true)
@AllArgsConstructor(access = AccessLevel.PROTECTED)
public class IterableStringBuilder<T> {
    /**
     * 默认元素分隔符
     */
    public final static String DEFAULT_ELEM_SPLIT = ",";
    /**
     * 可迭代的对象
     */
    private Iterable<T> iterable;

    /**
     * 元素分隔符
     */
    private CharSequence elemSplit;
    /**
     * 元素前缀
     */
    private CharSequence elemPre;
    /**
     * 元素后缀
     */
    private CharSequence elemSuf;
    /**
     * 整体前缀
     */
    private CharSequence prefix;
    /**
     * 整体后缀
     */
    private CharSequence suffix;
    /**
     * 过滤器
     */
    private Predicate<T> filter;

    protected IterableStringBuilder(Iterable<T> iterable) {
        this(iterable, null, null, null, null, null, null);
    }

    /**
     * 可迭代的对象的元素数量
     *
     * @return 可迭代的对象的元素数量
     */
    public int size() {
        if (null == iterable) {
            return 0;
        }

        if (iterable instanceof Collection<?>) {
            return ((Collection<?>) iterable).size();
        } else {
            int size = 0;
            for (T t : iterable) {
                size++;
            }
            return size;
        }
    }

    /**
     * 映射
     *
     * @param mapper 映射逻辑
     * @param <R>    映射结果类型
     * @return IterableToStrHelper
     */
    public <R> IterableStringBuilder<R> map(Function<T, R> mapper) {
        List<R> list = new ArrayList<>();
        if (iterable != null && mapper != null) {
            iterable.forEach(e -> {
                if (LogicUtil.filter(filter, e)) {
                    list.add(mapper.apply(e));
                }
            });
        }
        return new IterableStringBuilder<R>(list, elemSplit, elemPre, elemSuf, prefix, suffix, null);
    }

    /**
     * 替换
     *
     * @param target      被替换旧字符串
     * @param replacement 替换新字符串
     * @return IterableToStrHelper
     */
    public IterableStringBuilder<String> replace(CharSequence target, CharSequence replacement) {
        return map(e -> String.valueOf(e).replace(target, replacement));
    }

    /**
     * 正则替换
     *
     * @param regex       正则表达式
     * @param replacement 替换新字符串
     * @return IterableToStrHelper
     */
    public IterableStringBuilder<String> replaceAll(String regex, String replacement) {
        return map(e -> String.valueOf(e).replaceAll(regex, replacement));
    }

    /**
     * 修剪
     * <p>
     * 去掉字符串左右的空格
     *
     * @return IterableToStrHelper
     */
    public IterableStringBuilder<String> trim() {
        return map(e -> String.valueOf(e).trim());
    }

    /**
     * 转为全大写
     *
     * @return IterableToStrHelper
     */
    public IterableStringBuilder<String> upperCase() {
        return map(e -> String.valueOf(e).toUpperCase(Locale.ROOT));
    }

    /**
     * 转为全小写
     *
     * @return IterableToStrHelper
     */
    public IterableStringBuilder<String> lowerCase() {
        return map(e -> String.valueOf(e).toLowerCase(Locale.ROOT));
    }

    /**
     * 首字母大写
     *
     * @return IterableToStrHelper
     */
    public IterableStringBuilder<String> upperFirst() {
        return map(e -> StrUtil.upperFirst(String.valueOf(e)));
    }

    /**
     * 首字母小写
     *
     * @return IterableToStrHelper
     */
    public IterableStringBuilder<String> lowerFirst() {
        return map(e -> StrUtil.lowerFirst(String.valueOf(e)));
    }

    @Override
    public String toString() {
        StringBuilder str = new StringBuilder();
        // 整体前缀
        StrUtil.append(str, prefix);
        if (iterable != null) {
            boolean isEmpty = true;
            for (T e : iterable) {
                if (LogicUtil.filter(filter, e)) {
                    // 元素分隔符
                    StrUtil.append(!isEmpty, str, ObjectUtil.defaultIfNull(elemSplit, DEFAULT_ELEM_SPLIT));
                    // 元素前缀
                    StrUtil.append(str, elemPre);
                    // 元素
                    StrUtil.append(str, e);
                    // 元素后缀
                    StrUtil.append(str, elemSuf);

                    isEmpty = false;
                }
            }
        }
        // 整体后缀
        StrUtil.append(str, suffix);
        return str.toString();
    }

    /**
     * 转为字符串
     * <p>
     * toString方法的别名
     *
     * @return 字符串
     */
    public String str() {
        return toString();
    }

    /**
     * 转为字符串后非空时返回该字符串，否则返回elseStr
     *
     * @param elseStr 其他字符串
     * @return 字符串
     */
    public String elseIfEmpty(String elseStr) {
        return ObjectUtil.defaultIfEmpty(str(), elseStr);
    }

    /**
     * 转为字符串后非空且非空格时返回该字符串，否则返回elseStr
     *
     * @param elseStr 其他字符串
     * @return 字符串
     */
    public String elseIfBlank(String elseStr) {
        return ObjectUtil.defaultIfBlank(str(), elseStr);
    }
}

注意有使用lombok