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

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

package com.kovizone.util;

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

import javax.validation.constraints.NotNull;
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> {
    /**
     * 可迭代的对象
     */
    private Iterable<T> iter;

    /**
     * 元素分隔符
     */
    private Object elemSplit;
    /**
     * 元素前缀
     */
    private Object elemPre;
    /**
     * 元素后缀
     */
    private Object elemSuf;
    /**
     * 整体前缀
     */
    private Object prefix;
    /**
     * 整体后缀
     */
    private Object suffix;
    /**
     * 整体前缀（当迭代存在时）
     */
    private Object prefixIfPresent;
    /**
     * 整体后缀（当迭代存在时）
     */
    private Object suffixIfPresent;
    /**
     * 过滤器
     */
    private Predicate<T> filter;

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

    /**
     * 可迭代的对象的元素数量
     *
     * @return 可迭代的对象的元素数量
     */
    public int size() {
        if (iter == null) {
            return 0;
        }
        if (iter instanceof Collection) {
            return ((Collection<?>) iter).size();
        }
        int size = 0;
        for (T t : iter) {
            size++;
        }
        return size;
    }

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

    @NotNull
    @Override
    public String toString() {
        StringBuilder str = new StringBuilder();
        if (size() > 0) {
            boolean isPresent = false;
            for (T e : iter) {
                if (LogicUtil.filter(filter, e)) {
                    // 元素分隔符
                    StrUtil.append(isPresent, str, elemSplit);
                    // 元素前缀
                    StrUtil.append(str, elemPre);
                    // 元素
                    StrUtil.append(str, e);
                    // 元素后缀
                    StrUtil.append(str, elemSuf);

                    isPresent = true;
                }
            }

            // 整体前缀（当遍历对象存在时）
            StrUtil.appendLeft(isPresent, str, prefixIfPresent);
            // 整体后缀（当遍历对象存在时）
            StrUtil.append(isPresent, str, suffixIfPresent);
        }
        // 整体前缀
        StrUtil.appendLeft(str, prefix);
        // 整体后缀
        StrUtil.append(str, suffix);
        return str.toString();
    }

    /**
     * 转为字符串
     * <p>
     * toString方法的别名
     *
     * @return 字符串
     */
    @NotNull
    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);
    }

    /**
     * 设置整体前缀
     *
     * @param ifPresent 是否当遍历对象存在时
     * @param prefix    整体前缀
     * @return 本例
     */
    public IterableStringBuilder<T> setPrefix(boolean ifPresent, Object prefix) {
        if (ifPresent) {
            return setPrefixIfPresent(prefix);
        }
        return setPrefix(prefix);
    }

    /**
     * 设置整体后缀
     *
     * @param ifPresent 是否当遍历对象存在时
     * @param suffix    整体后缀
     * @return 本例
     */
    public IterableStringBuilder<T> setSuffix(boolean ifPresent, Object suffix) {
        if (ifPresent) {
            return setSuffixIfPresent(suffix);
        }
        return setSuffix(suffix);
    }

    /**
     * 设置整体前缀和整体后缀
     *
     * @param prefix 整体前缀
     * @param suffix 整体后缀
     * @return 本例
     */
    public IterableStringBuilder<T> setWrap(Object prefix, Object suffix) {
        return setWrap(false, prefix, suffix);
    }

    /**
     * 设置整体前缀和整体后缀
     *
     * @param ifPresent 是否当遍历对象存在时
     * @param prefix    整体前缀
     * @param suffix    整体后缀
     * @return 本例
     */
    public IterableStringBuilder<T> setWrap(boolean ifPresent, Object prefix, Object suffix) {
        return setPrefix(ifPresent, prefix).setSuffix(ifPresent, suffix);
    }

    /**
     * 设置元素前缀和元素后缀
     *
     * @param elemPre 元素前缀
     * @param elemSuf 元素后缀
     * @return 本例
     */
    public IterableStringBuilder<T> setElemWrap(Object elemPre, Object elemSuf) {
        return setElemPre(elemPre).setElemSuf(elemSuf);
    }
}

注意有使用lombok