Stream流式编程工具类，开发必备

把自己写的流式编程工具分享出来，不涉及公司业务，非常便捷，不用在业务层看到一条龙式的Stream代码了；

大家用的最多的应该是转list，转set，以及setVFromE；

觉得好用点个赞就行

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections.CollectionUtils;

/**
 * @desc Stream流处理工具
 */
public class StreamUtils {

    /**
     * 转换map，获取本身，去重，对象、key忽略null
     * @param source 集合
     * @param keyFunction 获取key函数
     * @return
     */
    public static <T,K> Map<K,T> toMap(Collection<T> source, Function<T,K> keyFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(obj -> Objects.nonNull(keyFunction.apply(obj)))
                .collect(Collectors.toMap(keyFunction, Function.identity(), (v1, v2) -> v2));
    }

    /**
     * 转换map，获取本身，去重，对象、key忽略null
     * @param source 集合
     * @param keyFunction 获取key函数
     * @param predicate 过滤条件
     * @return
     */
    public static <T,K> Map<K,T> toMap(Collection<T> source, Function<T,K> keyFunction, Predicate<? super T> predicate){
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(obj -> Objects.nonNull(keyFunction.apply(obj))).filter(predicate)
                .collect(Collectors.toMap(keyFunction, Function.identity(), (v1, v2) -> v2));
    }

    /**
     * 转换map，去重，对象、key、value忽略null
     * @param source 集合
     * @param keyFunction 获取key函数
     * @param valueFunction 获取值函数
     * @return
     */
    public static <T, K, V> Map<K, V> toMap(Collection<T> source, Function<T, K> keyFunction, Function<T, V> valueFunction) {
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(obj -> Objects.nonNull(keyFunction.apply(obj)))
                .filter(obj -> Objects.nonNull(valueFunction.apply(obj)))
                .collect(Collectors.toMap(keyFunction, valueFunction, (v1, v2) -> v2));
    }

    /**
     * 转换map，去重，对象、key、value忽略null
     * @param source 集合
     * @param keyFunction 获取key函数
     * @param valueFunction 获取值函数
     * @param mergeFunction 合并方式
     * @return
     */
    public static <T, K, V> Map<K, V> toMap(Collection<T> source, Function<T, K> keyFunction, Function<T, V> valueFunction, BinaryOperator<V> mergeFunction) {
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(obj -> Objects.nonNull(keyFunction.apply(obj)))
                .filter(obj -> Objects.nonNull(valueFunction.apply(obj))).collect(
                Collectors.toMap(keyFunction, valueFunction, mergeFunction));
    }

    /**
     * 转换map，去重，使用map重新put方式
     * @param source 集合
     * @param keyFunction 获取key函数
     * @param valueFunction 获取值函数
     * @return
     */
    public static <T, K, V> HashMap<K, V> toMap2(Collection<T> source, Function<T, K> keyFunction, Function<T, V> valueFunction) {
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(obj -> Objects.nonNull(keyFunction.apply(obj))).collect(
                HashMap<K, V>::new,
                (m, v) -> m.put(keyFunction.apply(v), valueFunction.apply(v)),
                HashMap<K, V>::putAll);
    }

    public static <T, R> List<R> toList(Collection<T> source, Function<T, R> function) {
        if (CollectionUtils.isEmpty(source)) {
            return Lists.newArrayList();
        }
        return source.stream().filter(Objects::nonNull).map(function)
                .collect(Collectors.toList());
    }

    public static <T, R> List<R> toListIgnoreNull(Collection<T> source, Function<T, R> function) {
        if (CollectionUtils.isEmpty(source)) {
            return Lists.newArrayList();
        }
        return source.stream().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
                .collect(Collectors.toList());
    }

    public static <T,R> Set<R> toSet(Collection<T> source, Function<T,R> function) {
        if (CollectionUtils.isEmpty(source)) {
            return Sets.newHashSet();
        }
        return source.stream().filter(Objects::nonNull).map(function)
                .collect(Collectors.toSet());
    }

    public static <T,R> Set<R> toSetIgnoreNull(Collection<T> source, Function<T,R> function) {
        if (CollectionUtils.isEmpty(source)) {
            return Sets.newHashSet();
        }
        return source.stream().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
                .collect(Collectors.toSet());
    }

    public static <T,R> LinkedHashSet<R> toLinkedHashSet(Collection<T> source, Function<T,R> function) {
        if (CollectionUtils.isEmpty(source)) {
            return new LinkedHashSet<R>();
        }
        return source.stream().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
                .collect(Collectors.toCollection(LinkedHashSet::new));
    }

    public static <T,R> LinkedList<R> toLinkedList(Collection<T> source, Function<T,R> function) {
        if (CollectionUtils.isEmpty(source)) {
            return Lists.newLinkedList();
        }
        return source.stream().filter(Objects::nonNull).map(function).filter(Objects::nonNull)
                .collect(Collectors.toCollection(LinkedList::new));
    }

    /**
     * 将集合分组，遇到重复的key，value放入集合中
     * @param source
     * @param keyFunction
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K,V> Map<K,List<V>> groupToMap(Collection<V> source,Function<? super V, ? extends K> keyFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(s -> Objects.nonNull(keyFunction.apply(s)))
                .collect(Collectors.groupingBy(keyFunction));
    }

    /**
     * 将集合分组，遇到重复的key，value放入集合中
     * @param source
     * @param keyFunction
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K,V> LinkedHashMap<K,List<V>> groupToLinkedHashMap(Collection<V> source,Function<? super V, ? extends K> keyFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newLinkedHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(s -> Objects.nonNull(keyFunction.apply(s)))
                .collect(Collectors.groupingBy(keyFunction, LinkedHashMap::new, Collectors.toList()));
    }

    /**
     * 将集合分组，遇到重复的key，并统计重复key的次数
     * @param source
     * @param keyFunction
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K,V> Map<K,Long> groupToMapCount(Collection<V> source,Function<? super V, ? extends K> keyFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Maps.newHashMap();
        }
        return source.stream().filter(Objects::nonNull).filter(s -> Objects.nonNull(keyFunction.apply(s)))
                .collect(Collectors.groupingBy(keyFunction,Collectors.counting()));
    }


    public static <T> List<T> filter(Collection<T> source,Predicate<? super T> predicate){
        if (CollectionUtils.isEmpty(source)) {
            return Lists.newArrayList();
        }
        return source.stream().filter(predicate).collect(Collectors.toList());
    }

    public static <T> Set<T> filter(Set<T> set,Predicate<? super T> predicate){
        if (CollectionUtils.isEmpty(set)) {
            return Sets.newHashSet();
        }
        return set.stream().filter(predicate).collect(Collectors.toCollection(HashSet::new));
    }

    public static <T> LinkedHashSet<T> filterToSet(Collection<T> source,Predicate<? super T> predicate){
        if (CollectionUtils.isEmpty(source)) {
            return Sets.newLinkedHashSet();
        }
        return source.stream().filter(predicate).collect(Collectors.toCollection(LinkedHashSet::new));
    }

    public static <T> Stream<T> filterStream(Collection<T> source, Predicate<? super T> predicate){
        if (CollectionUtils.isEmpty(source)) {
            return Stream.empty();
        }
        return source.stream().filter(predicate);
    }

    public static <T> Stream<T> filterStream(Collection<T> source, Predicate<? super T> predicate1, Predicate<? super T> predicate2){
        if (CollectionUtils.isEmpty(source)) {
            return Stream.empty();
        }
        return source.stream().filter(predicate1).filter(predicate2);
    }

    public static <T,R> List<R> filterMapList(Collection<T> source, Predicate<? super T> predicate, Function<T , R> mapFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Lists.newArrayList();
        }
        return source.stream().filter(predicate).map(mapFunction).collect(Collectors.toList());
    }

    public static <T,R> List<R> filterMapList(Collection<T> source, Predicate<? super T> predicate1, Predicate<? super T> predicate2, Function<T , R> mapFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Lists.newArrayList();
        }
        return source.stream().filter(predicate1).filter(predicate2).map(mapFunction).collect(Collectors.toList());
    }

    public static <T,R> Set<R> filterMapSet(Collection<T> source, Predicate<? super T> predicate, Function<T , R> mapFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Sets.newHashSet();
        }
        return source.stream().filter(predicate).map(mapFunction).collect(Collectors.toSet());
    }

    public static <T,R> Set<R> filterMapSet(Collection<T> source, Predicate<? super T> predicate1,Predicate<? super T> predicate2, Function<T , R> mapFunction){
        if (CollectionUtils.isEmpty(source)) {
            return Sets.newHashSet();
        }
        return source.stream().filter(predicate1).filter(predicate2).map(mapFunction).collect(Collectors.toSet());
    }

    /**
     * 从eList中设置字段值到vList中
     * @param vList vList v对象集合
     * @param eList eList e对象集合
     * @param keyFunctionE e对象获取key方法
     * @param keyFunctionV v对象获取key方法
     * @param consumer 赋值转换方法
     */
    public static <V,E,R> void setVFromE(Collection<V> vList, Collection<E> eList, Function<E,R> keyFunctionE,
                                              Function<V,R> keyFunctionV,
                                              BiConsumer<V,E> consumer){
        if (CollectionUtils.isNotEmpty(eList)) {
            Map<R, E> map = StreamUtils.toMap(eList,keyFunctionE);
            vList.stream().filter(Objects::nonNull).forEach(v -> {
                E e = map.get(keyFunctionV.apply(v));
                if (Objects.nonNull(e)) {
                    consumer.accept(v,e);
                }
            });
        }
    }

    /**
     * 从eList中设置集合项字段值到vList中的集合项属性
     * @param vList vList v对象集合
     * @param eList eList e对象集合
     * @param keyFunctionE e对象获取key方法
     * @param keyFunctionV v对象获取key方法
     * @param consumer 赋值转换方法
     */
    public static <V,E,R> void setVListFromE(Collection<V> vList, Collection<E> eList, Function<E,R> keyFunctionE,
                                         Function<V,R> keyFunctionV,
                                         BiConsumer<V,List<E>> consumer){
        if (CollectionUtils.isNotEmpty(eList)) {
            Map<R, List<E>> map = StreamUtils.groupToMap(eList,keyFunctionE);
            vList.stream().filter(Objects::nonNull).forEach(v -> {
                List<E> e = map.get(keyFunctionV.apply(v));
                if (Objects.nonNull(e)) {
                    consumer.accept(v,e);
                }
            });
        }
    }

    /**
     * 累加
     * @param source 原集合
     * @param valueFunction 获取BigDecimal字段
     * @param <T>
     * @return
     */
    public static <T> BigDecimal add(Collection<T> source, Function<T,BigDecimal> valueFunction) {
        if (CollectionUtils.isEmpty(source)) {
            return BigDecimal.ZERO;
        }
        return source.stream().filter(Objects::nonNull).map(valueFunction)
                .reduce(BigDecimal.ZERO,BigDecimal::add);
    }

    /**
     * 累加并设置四舍五入（保留newScale位小数）
     * @param source 原集合
     * @param valueFunction 获取BigDecimal字段
     * @param newScale 小数位数
     * @param <T>
     * @return
     */
    public static <T> BigDecimal addHalfUp(Collection<T> source, Function<T,BigDecimal> valueFunction,int newScale) {
        if (CollectionUtils.isEmpty(source)) {
            return BigDecimal.ZERO;
        }
        return source.stream().filter(Objects::nonNull).map(valueFunction)
                .reduce(BigDecimal.ZERO,BigDecimal::add).setScale(newScale, RoundingMode.HALF_UP);
    }

    /**
     * 累加并设置四舍五入（保留2位小数）
     * @param source 原集合
     * @param valueFunction 获取BigDecimal字段
     * @param <T>
     * @return
     */
    public static <T> BigDecimal addHalfUp(Collection<T> source, Function<T,BigDecimal> valueFunction) {
       return addHalfUp(source, valueFunction,2);
    }

    public static <T,K> Predicate<T> distinctByKey(Function<? super T, K> keyExtractor) {
        Set<K> seen = ConcurrentHashMap.newKeySet();
        return t -> seen.add(keyExtractor.apply(t));
    }



    public static <T,K> List<T> distinctByKey(List<T> list, Function<? super T, K> keyExtractor) {
        return list.stream().filter(distinctByKey(keyExtractor)).collect(Collectors.toList());
    }
}