Lambda — Stream API常用工具类

最近发现代码里面大量处理集合的lambda表达式，所以想着封装个常用工具类，用来快速调用，直接贴代码

只需传入集合，Function，Predicate，Comparator等即可。上手简单，让代码更简洁。

package com.example.declaration.util;

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.stream.Collectors;

/**
 * @Author ZhuZiKai
 * @Description 封装Lambda常用方法
 * @date 2021/12/14 10:08
 */
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<>());
    }
}