工具类

public class LambdaUtil {
    /**
     * 通过条件分组
     *
     * @param list
     * @param func
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> Map<R, List<T>> groupingBy(List<T> list, Function<T, R> func) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().collect(Collectors.groupingBy(func, Collectors.toList())))
                .orElse(new HashMap<>());
    }

    /**
     * 以自身为value的map
     *
     * @param list
     * @param keyFunc
     * @param valueFunc
     * @param <R>
     * @param <T>
     * @return
     */
    public static <R, T> Map<R, T> toIdentityMap(List<T> list, Function<T, R> keyFunc, Function<T, T> valueFunc) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().collect(Collectors.toMap(keyFunc, valueFunc)))
                .orElse(new HashMap<>());
    }

    /**
     * 以String为value的map
     *
     * @param list
     * @param keyFunc
     * @param valueFunc
     * @param <R>
     * @param <T>
     * @return
     */
    public static <R, T> Map<R, String> toStringMap(List<T> list, Function<T, R> keyFunc, Function<T, String> valueFunc) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().collect(Collectors.toMap(keyFunc, valueFunc)))
                .orElse(new HashMap<>());
    }

    /**
     * 以integer为value的map
     *
     * @param list
     * @param keyFunc
     * @param valueFunc
     * @param <R>
     * @param <T>
     * @return
     */
    public static <R, T> Map<R, Integer> toIntegerMap(List<T> list, Function<T, R> keyFunc, Function<T, Integer> valueFunc) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().collect(Collectors.toMap(keyFunc, valueFunc)))
                .orElse(new HashMap<>());
    }

    /**
     * 获取某个字段list
     *
     * @param list
     * @param func
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> map(List<T> list, Function<T, R> func) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().map(func).collect(Collectors.toList()))
                .orElse(new ArrayList<>());
    }

    public static <T, R> List<R> map(Set<T> list, Function<T, R> func) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().map(func).collect(Collectors.toList()))
                .orElse(new ArrayList<>());
    }

    /**
     * double求和
     *
     * @param list
     * @param func
     * @param <T>
     * @return
     */
    public static <T> Double doubleSum(List<T> list, ToDoubleFunction<T> func) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().mapToDouble(func).sum())
                .orElse(0.00);
    }

    /**
     * integer求和
     *
     * @param list
     * @param func
     * @param <T>
     * @return
     */
    public static <T> Integer integerSum(List<T> list, ToIntFunction<T> func) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().mapToInt(func).sum())
                .orElse(0);
    }

    /**
     * list总条数
     *
     * @param list
     * @param pred
     * @param <T>
     * @return
     */
    public static <T> Long count(List<T> list, Predicate<T> pred) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().filter(pred).count())
                .orElse(0L);
    }

    /**
     * 通过条件过滤list
     *
     * @param list
     * @param pred
     * @param <T>
     * @return
     */
    public static <T> List<T> filter(List<T> list, Predicate<T> pred) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().filter(pred).collect(Collectors.toList()))
                .orElse(new ArrayList<>());
    }

    /**
     * 通过条件分组
     *
     * @param list
     * @param func
     * @param <T>
     * @return
     */
    public static <T> List<T> sorted(List<T> list, Comparator<T> func) {
        return Optional.ofNullable(list)
                .map(l -> l.stream().sorted(func).collect(Collectors.toList()))
                .orElse(new ArrayList<>());
    }

     /**
     * 参数为true或false时，分别进行不同的操作
     *
     * @param b
     * @return
     */
    public static BranchHandle isTrueOrFalse(boolean b) {
        return (trueHandle, falseHandle) -> {
            if (b) {
                Optional.ofNullable(trueHandle).ifPresent(Runnable::run);
            } else {
                Optional.ofNullable(falseHandle).ifPresent(Runnable::run);
            }
        };
    }

    /**
     * 参数为空和非空时进行的操作
     *
     * @param t
     * @return
     */
    public static <T> PresentOrElseHandler isBlankOrNotBlank(T t) {
        return (action, emptyAction) -> {
            if (ObjectUtils.isEmpty(t)) {
                emptyAction.run();
            } else {
                action.accept(t);
            }
        };
    }
}

PresentOrElseHandler函数式接口

/**
 * @author tsj
 * @version 1.0.0
 * @ClassName PresentOrElseHandler.java
 * @Description 如果存在值执行消费操作，否则执行基于空的操作
 * @createTime 2021年12月06日 14:00:00
 */
@FunctionalInterface
public interface PresentOrElseHandler<T extends  Object> {

    /**
     * 值不为空时进行消费操作
     * 值为空时执行其他操作
     * @param action 值不为空时，执行的消费操作
     * @param emptyAction 值为空时，执行的操作
     * @return void
     */
    void presentOrElseHandle(Consumer<? extends T> action,Runnable emptyAction);

}

BranchHandle函数式接口

/**
 * @author tsj
 * @version 1.0.0
 * @ClassName BranchHandle.java
 * @Description 分支处理接口
 * @createTime 2021年12月06日 13:48:00
 */
@FunctionalInterface
public interface BranchHandle {

    /**
     * 分支操作
     * @param trueHandle 为true时要进行的操作
     * @param falseHandle 为false要进行的操作
     * @return void
     */
    void trueOrFalseHandle(Runnable trueHandle,Runnable falseHandle);

}