jdk8 Stream的封装工具类

为了减少重复代码，抽取stream实际中的常用方法封装。

import java.math.BigDecimal;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.ToLongFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static java.util.stream.Collectors.groupingBy;

/**
 * 描述 : stream的封装工具类.
 *
 * @author : ada
 */
public class StreamUtil {

    /**
     * 把流中的某一元素用连接标志连接成一个字符串.
     *
     * @param stream   流.
     * @param func     函数.
     * @param joinFlag 连接标志.
     * @param <T>      函数的入参.
     * @return String.
     */
    public static <T> String join(Stream<T> stream, Function<T, String> func, String joinFlag) {
        return stream.map(func).collect(Collectors.joining(joinFlag));
    }

    /**
     * 从流中抽取<R>，生成字符串数组.
     *
     * @param stream 流.
     * @param func   传入的函数.
     * @param <T>    函数的入参.
     * @return List<R>.
     */
    public static <T> String[] mapToStrArray(Stream<T> stream, Function<T, String> func) {
        return stream
                .map(func)
                .toArray(String[]::new);
    }

    /**
     * 从流中抽取<R>，生成集合List<R>.
     *
     * @param stream 流.
     * @param func   传入的函数.
     * @param <T>    函数的入参.
     * @param <R>    函数的出参.
     * @return List<R>.
     */
    public static <T, R> List<R> mapToList(Stream<T> stream, Function<T, R> func) {
        return stream
                .map(func)
                .collect(Collectors.toList());
    }

    /**
     * 从流中抽取<R>，生成去重集合Set<R>.
     *
     * @param stream 流.
     * @param func   传入的函数.
     * @param <T>    函数的入参.
     * @param <R>    函数的出参.
     * @return Set<R>.
     */
    public static <T, R> Set<R> mapToSet(Stream<T> stream, Function<T, R> func) {
        return stream
                .map(func)
                .collect(Collectors.toSet());
    }

    /**
     * 从流中抽取<R>，生成Map<R,T>.
     *
     * @param stream 流.
     * @param func   传入的函数.
     * @param <T>    函数的入参.
     * @param <R>    函数的出参.
     * @return Map<R, T>.
     */
    public static <T, R> Map<R, T> identity(Stream<T> stream, Function<T, R> func) {
        return stream.collect(Collectors.toMap((func), Function.identity()));
    }

    /**
     * 从流中抽取<R>，根据R的不同值生成Map<R,List<T>>.
     *
     * @param stream 流.
     * @param func   传入的函数.
     * @param <T>    函数的入参.
     * @param <R>    函数的出参.
     * @return Map<R, List < T>>.
     */
    public static <T, R> Map<R, List<T>> groupBy(Stream<T> stream, Function<T, R> func) {
        return stream.collect(groupingBy(func));
    }

    /**
     * 从流中抽取满足条件函数predicate的元素，生成List<T>.
     *
     * @param stream    流.
     * @param predicate 返回boolean的函数.
     * @param <T>       函数的入参.
     * @return List<T>.
     */
    public static <T> List<T> filter(Stream<T> stream, Predicate<T> predicate) {
        return stream
                .filter(predicate)
                .collect(Collectors.toList());
    }

    /**
     * 从流中抽取满足条件函数predicate的元素，选取第一个.
     *
     * @param stream    流.
     * @param predicate 返回boolean的函数.
     * @param t         没有第一个默认，指定返回.
     * @param <T>       函数的入参.
     * @return List<T>.
     */
    public static <T> T filterFirst(Stream<T> stream, Predicate<T> predicate, T t) {
        return stream
                .filter(predicate)
                .findFirst()
                .orElse(t);
    }

    /**
     * 从流中抽取满足条件函数predicate的元素，生成List<T>.
     *
     * @param stream    流.
     * @param predicate 返回boolean的函数.
     * @param <T>       函数的入参.
     * @return List<T>.
     */
    public static <T> List<T> filterSort(Stream<T> stream, Predicate<T> predicate, Comparator<T> comparator) {
        return stream
                .filter(predicate)
                .sorted(comparator)
                .collect(Collectors.toList());
    }


    /**
     * 从流中抽取满足条件函数predicate的元素，并按func的出参进行排序，生成有序List<T>.
     *
     * @param stream    流.
     * @param predicate 条件函数.
     * @param func      函数.
     * @param <T>       条件函数的入参.
     * @param <U>       函数的出参.
     * @return List<T>.
     */
    public static <T, U extends Comparable<? super U>> List<T> filterSort(Stream<T> stream,
                                                                          Predicate<T> predicate,
                                                                          Function<T, U> func) {
        return stream
                .filter(predicate)
                .sorted(Comparator.comparing(func))
                .collect(Collectors.toList());
    }

    /**
     * 统计流中某项类型为Long的元素之和.
     *
     * @param stream 流.
     * @param func   函数.
     * @param <T>    函数的入参.
     * @return Long.
     */
    public static <T> Long filterSumLong(Stream<T> stream, ToLongFunction<T> func) {
        return stream
                .filter(obj -> Objects.nonNull(func))
                .mapToLong(func)
                .sum();
    }

    /**
     * 统计流中某项类型为BigDecimal的元素之和.
     *
     * @param stream 流.
     * @param func   函数.
     * @param <T>    函数的入参.
     * @return BigDecimal.
     */
    public static <T> BigDecimal filterSumBigDecimal(Stream<T> stream, Function<T, BigDecimal> func) {
        return stream
                .filter(obj -> Objects.nonNull(func))
                .map(func)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
    }

    /**
     * 从流中抽取满足条件函数predicate的元素，并返回元素数量.
     *
     * @param stream    流.
     * @param predicate 条件函数.
     * @param <T>       函数的入参.
     * @return List<T>.
     */
    public static <T> long count(Stream<T> stream, Predicate<T> predicate) {
        return stream
                .filter(predicate)
                .count();
    }

    /**
     * 统计流中<R>的不同类型的数量.
     *
     * @param stream 流.
     * @param func   函数.
     * @param <T>    函数的入参.
     * @param <R>    函数的出参.
     * @return List<T>.
     */
    public static <T, R> Map<R, Long> mapCount(Stream<T> stream, Function<T, R> func) {
        return stream.collect(Collectors.groupingBy(func, Collectors.counting()));
    }

    /**
     * 流中的元素按比较函数排序，选出最大的元素。无，则手动返回.
     *
     * @param stream     流.
     * @param comparator 比较函数.
     * @param obj        当没有找到最大元素的返回值.
     * @param <T>        函数的入参.
     * @return List<T>.
     */
    public static <T> T max(Stream<T> stream, Comparator<T> comparator, T obj) {
        return stream
                .max(comparator)
                .orElse(obj);
    }

    /**
     * 如果流中有任一元素满足条件predicate，则返回true,反之，则返回false.
     *
     * @param stream    流.
     * @param predicate 条件函数.
     * @param <T>       函数的入参.
     * @return boolean.
     */
    public static <T> boolean anyMatch(Stream<T> stream, Predicate<T> predicate) {
        return stream.anyMatch(predicate);
    }


    public static void main(String[] args) {
//        List<Stream> recordList = new ArrayList<>();
//        Stream stream = recordList.stream();
//        Predicate<String> predicate = tmp -> tmp.equals("111");
//        Comparator<BigDecimal> comparator = Comparator.comparing(BigDecimal::intValue);
//        Function<Integer, String> func = tmp -> tmp + "";
    }

}