封裝集合Stream常用功能,讓代碼更簡潔,不依賴任何第三方,復制即用

提前祝大家,牛年大吉,代碼無Bug

import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @Author: 小胖
 * @Version: 1.0
 * @Description: 集合流工具類
 * @Date: 2021/01/26  09:10
 **/
@SuppressWarnings("all")
public class StreamUtils
{
    /**
     * 陣列轉集合
     * 出現空指標,回傳一個空集合
     * @param array 陣列
     * @param <T>
     * @return  集合
     */
    public static <T> List<T> arrayToList(T[] array)
    {
        try
        {
            return Arrays.asList(array);
        }
        catch (NullPointerException e)
        {
            return new ArrayList<>();
        }
    }

    /**
     * 判斷集合是否為空
     * @param list
     * @return  true:為空     false:不為空
     */
    public static boolean isEmpty(Collection<?> list)
    {
        return Objects.isNull(list) || list.isEmpty();
    }

    // ------------------------------------------filter------------------------------------------------------

    /**
     * 過濾一個集合,獲取一個新集合
     * 如果集合為慷訓者是null,回傳一個空ArrayList
     * @param list      原list
     * @param predicate 過濾條件
     * @param <T>   物件型別
     * @return  過濾后的集合
     */
    public static <T> List<T> filter(Collection<T> list, Predicate<? super T> predicate)
    {
        return isEmpty(list) ? new ArrayList<>() : list.stream().filter(predicate).collect(Collectors.toList());
    }

    /**
     * 過濾一個陣列,獲取一個新集合
     * 如果陣列為慷訓者是null,回傳一個空ArrayList
     * @param array      原陣列
     * @param predicate 過濾條件
     * @param <T>   物件型別
     * @return  過濾后的集合
     */
    public static <T> List<T> filter(T[] array, Predicate<? super T> predicate)
    {
        return filter(arrayToList(array), predicate);
    }

    // ------------------------------------------filterLimitOne------------------------------------------------------

    /**
     * 獲取陣列中一個滿足條件的資料
     * 陣列為空 OR 沒有符合條件的資料
     * 拋出例外
     * @param list          資料陣列
     * @param predicate     過濾條件
     * @param <T>           資料型別
     * @return              獲取到的物件
     */
    public static <T> T filterLimitOne(T[] array, Predicate<? super T> predicate)
    {
        return filterLimitOne(arrayToList(array), predicate, null);
    }

    /**
     * 獲取集合中一個滿足條件的資料
     * 集合為空 OR 沒有符合條件的資料
     * 拋出例外
     * @param list          資料陣列
     * @param predicate     過濾條件
     * @param <T>           資料型別
     * @return              獲取到的物件
     */
    public static <T> T filterLimitOne(Collection<T> list, Predicate<? super T> predicate)
    {
        return filterLimitOne(list, predicate, null);
    }

    /**
     * 獲取集合中一個滿足條件的資料
     * 集合為空 OR 沒有符合條件的資料
     * 回傳默認值
     * @param list          資料集合
     * @param predicate     過濾條件
     * @param def           默認值
     * @param <T>           資料型別
     * @return              獲取到的物件
     */
    public static <T> T filterLimitOne(Collection<T> list, Predicate<? super T> predicate, T def)
    {
        boolean nonNull = Objects.nonNull(def);
        if (isEmpty(list))
        {
            if (nonNull)
            {
                return def;
            }
            throw new NoSuchElementException("沒有符合條件的資料");
        }
        List<T> filter = list.stream().filter(predicate).limit(1).collect(Collectors.toList());
        if (isEmpty(filter))
        {
            if (nonNull)
            {
                return def;
            }
            throw new NoSuchElementException("沒有符合條件的資料");
        }
        return filter.get(0);
    }

    /**
     * 獲取陣列中一個滿足條件的資料
     * 陣列為空 OR 沒有符合條件的資料
     * 回傳默認值
     * @param list          資料陣列
     * @param predicate     過濾條件
     * @param def           默認值
     * @param <T>           資料型別
     * @return              獲取到的物件
     */
    public static <T> T filterLimitOne(T[] array, Predicate<? super T> predicate, T def)
    {
        return filterLimitOne(arrayToList(array), predicate, def);
    }

    // ------------------------------------------groupingBy------------------------------------------------------

    /**
     * 將list集合以指定方式分組
     * 如果list為慷訓者是null,回傳一個空HashMap
     * @param list      元list
     * @param function  分組規則
     * @param <T>   物件型別
     * @param <K>   條件型別
     * @return  分組結果
     */
    public static<T,K> Map<K,List<T>> groupingBy(Collection<T> list, Function<? super T, ? extends K> function)
    {
        return isEmpty(list) ? new HashMap<>() : list.stream().collect(Collectors.groupingBy(function));
    }

    /**
     * 將陣列集合以指定方式分組
     * 如果陣列為慷訓者是null,回傳一個空HashMap
     * @param array      原陣列
     * @param function  分組規則
     * @param <T>   物件型別
     * @param <K>   條件型別
     * @return  分組結果
     */
    public static<T,K> Map<K,List<T>> groupingBy(T[] array, Function<? super T, ? extends K> function)
    {
        return groupingBy(arrayToList(array), function);
    }

    // ------------------------------------------filterGroupingBy------------------------------------------------------

    /**
     * 將集合篩選后
     * 以指定方式分組
     * 如果集合為慷訓者是null,回傳一個空HashMap
     * @param list      原list
     * @param predicate  過濾條件
     * @param function  分組規則
     * @param <T>   物件型別
     * @param <K>   條件型別
     * @return  分組結果
     */
    public static<T,K> Map<K,List<T>> filterGroupingBy(Collection<T> list, Predicate<? super T> predicate, Function<? super T, ? extends K> function)
    {
        return isEmpty(list) ? new HashMap<>() : list.stream().filter(predicate).collect(Collectors.groupingBy(function));
    }

    /**
     * 將陣列集合篩選后
     * 以指定方式分組
     * 如果陣列為慷訓者是null,回傳一個空HashMap
     * @param array      原陣列
     * @param predicate  過濾條件
     * @param function  分組規則
     * @param <T>   物件型別
     * @param <K>   條件型別
     * @return  分組結果
     */
    public static<T,K> Map<K,List<T>> filterGroupingBy(T[] array, Predicate<? super T> predicate, Function<? super T, ? extends K> function)
    {
        return filterGroupingBy(arrayToList(array), predicate, function);
    }

    // ------------------------------------------max------------------------------------------------------

    /**
     * 獲取集合中最大值
     * 如果集合為慷訓拋出例外
     * @param list  集合資料
     * @return  最大值
     */
    public static <T extends Comparable> T max(Collection<T> list)
    {
        return getMaxOrMin(list, null, true);
    }

    /**
     * 獲取集合中最大值
     * 如果集合為空,回傳默認值
     * @param list  集合資料
     * @param def  默認值
     * @return  最大值
     */
    public static <T extends Comparable> T max(Collection<T> list, T def)
    {
        return getMaxOrMin(list, def, true);
    }

    /**
     * 獲取陣列中最大值
     * 如果陣列為慷訓拋出例外
     * @param array  陣列資料
     * @return  最大值
     */
    public static <T extends Comparable> T max(T[] array)
    {
        return max(arrayToList(array));
    }

    /**
     * 獲取陣列中最大值
     * 如果陣列為空,回傳默認值
     * @param array  陣列資料
     * @param def  默認值
     * @return  最大值
     */
    public static <T extends Comparable> T max(T[] array, T def)
    {
        return max(arrayToList(array), def);
    }

    /**
     * 獲取集合中物件某個屬性的最大值
     * 如果集合為慷訓拋出例外
     * @param list  集合資料
     * @param mapper  需要獲取最大值的屬性
     * @return  最大值
     */
    public static <T, R extends Comparable> R max(Collection<T> list, Function<? super T, ? extends R> mapper)
    {
        return getMaxOrMin(map(list, mapper), null, true);
    }

    /**
     * 獲取集合中物件某個屬性的最大值
     * 如果集合為空,回傳默認值
     * @param list  集合資料
     * @param mapper  需要獲取最大值的屬性
     * @param def  需要獲取最大值的屬性
     * @return  最大值
     */
    public static <T, R extends Comparable> R max(Collection<T> list, Function<? super T, ? extends R> mapper, R def)
    {
        return getMaxOrMin(map(list, mapper), def, true);
    }

    /**
     * 獲取陣列中物件某個屬性的最大值
     * 如果陣列為慷訓拋出例外
     * @param array  陣列資料
     * @param mapper  需要獲取最大值的屬性
     * @return  最大值
     */
    public static <T, R extends Comparable> R max(T[] array, Function<? super T, ? extends R> mapper)
    {
        return getMaxOrMin(map(array, mapper), null, true);
    }

    /**
     * 獲取陣列中物件某個屬性的最大值
     * 如果陣列為空,回傳默認值
     * @param array  陣列資料
     * @param mapper  需要獲取最大值的屬性
     * @param def  默認值
     * @return  最大值
     */
    public static <T, R extends Comparable> R max(T[] array, Function<? super T, ? extends R> mapper, R def)
    {
        return getMaxOrMin(map(array, mapper), def, true);
    }

    // ------------------------------------------min------------------------------------------------------

    /**
     * 獲取集合中最小值
     * 如果集合為慷訓拋出例外
     * @param list  集合資料
     * @return  最小值
     */
    public static <T extends Comparable> T min(Collection<T> list)
    {
        return getMaxOrMin(list, null, false);
    }

    /**
     * 獲取集合中最小值
     * 如果集合為空,回傳默認值
     * @param list  集合資料
     * @param def  默認值
     * @return  最小值
     */
    public static <T extends Comparable> T min(Collection<T> list, T def)
    {
        return getMaxOrMin(list, def, false);
    }

    /**
     * 獲取array中最小值
     * 如果array為慷訓拋出例外
     * @param array  陣列資料
     * @return  最小值
     */
    public static <T extends Comparable> T min(T[] array)
    {
        return getMaxOrMin(arrayToList(array), null, false);
    }

    /**
     * 獲取array中最小值
     * 如果array為空,回傳默認值
     * @param array  陣列資料
     * @param def  默認值
     * @return  最小值
     */
    public static <T extends Comparable> T min(T[] array, T def)
    {
        return getMaxOrMin(arrayToList(array), def, false);
    }

    /**
     * 獲取集合中物件某個屬性的最小值
     * 如果集合為慷訓拋出例外
     * @param list  集合資料
     * @param mapper  需要獲取最小值的屬性
     * @return  最小值
     */
    public static <T, R extends Comparable> R min(Collection<T> list, Function<? super T, ? extends R> mapper)
    {
        return getMaxOrMin(map(list, mapper), null, false);
    }

    /**
     * 獲取陣列中物件某個屬性的最小值
     * 如果陣列為慷訓拋出例外
     * @param array  陣列資料
     * @param mapper  需要獲取最小值的屬性
     * @return  最小值
     */
    public static <T, R extends Comparable> R min(T[] array, Function<? super T, ? extends R> mapper)
    {
        return getMaxOrMin(map(array, mapper), null, false);
    }

    /**
     * 獲取集合中物件某個屬性的最小值
     * 如果集合為空,回傳默認值
     * @param list  集合資料
     * @param mapper  需要獲取最小值的屬性
     * @param def  默認值
     * @return  最小值
     */
    public static <T, R extends Comparable> R min(Collection<T> list, Function<? super T, ? extends R> mapper, R def)
    {
        return getMaxOrMin(map(list, mapper), def, false);
    }

    /**
     * 獲取陣列中物件某個屬性的最小值
     * 如果陣列為空,回傳默認值
     * @param array  陣列資料
     * @param mapper  需要獲取最小值的屬性
     * @param def  默認值
     * @return  最小值
     */
    public static <T, R extends Comparable> R min(T[] array, Function<? super T, ? extends R> mapper, R def)
    {
        return getMaxOrMin(map(array, mapper), def, false);
    }

    // ------------------------------------------sum------------------------------------------------------

    /**
     * 計算集合中資料的總和
     * 如果集合為空 OR 計算失敗,拋出例外
     * @param list  數字集合
     * @param <T>   數字型別
     * @return  總和
     */
    public static <T extends Number> T sum(Collection<T> list)
    {
        return sum(list, null);
    }

    /**
     * 計算陣列中資料的總和
     * 如果陣列為空 OR 計算失敗,拋出例外
     * 支持int,long,float,double數字型別
     * @param list  數字陣列
     * @param <T>   數字型別
     * @return  總和
     */
    public static <T extends Number> T sum(T[] array)
    {
        return sum(array, null);
    }

    /**
     * 計算集合中資料的總和
     * 如果集合為空 OR 計算失敗,回傳默認值
     * 支持int,long,float,double數字型別
     * @param list  數字集合
     * @param <T>   數字型別
     * @return  總和
     */
    public static <T extends Number> T sum(Collection<T> list, T def)
    {
        return getSum(list, def);
    }

    /**
     * 計算集合中資料的總和
     * 如果集合為空 OR 計算失敗,回傳默認值
     * 支持int,long,float,double數字型別
     * @param list  數字集合
     * @param <T>   數字型別
     * @return  總和
     */
    public static <T extends Number> T sum(T[] array, T def)
    {
        return sum(arrayToList(array), def);
    }

    /**
     * 計算集合中資料的總和
     * 如果集合為空 OR 計算失敗,回傳默認值
     * 支持int,long,float,double數字型別
     * @param list  物件集合
     * @param mapper    獲取數字屬性
     * @param def    默認值
     * @param <T>   物件型別
     * @param <R>   數字型別
     * @return  總和
     */
    public static <T, R extends Number> R sum(Collection<T> list, Function<? super T, ? extends R> mapper, R def)
    {
        return sum(map(list, mapper), def);
    }

    /**
     * 計算陣列中資料的總和
     * 如果陣列為空 OR 計算失敗,回傳默認值
     * 支持int,long,float,double數字型別
     * @param list  物件陣列
     * @param mapper    獲取數字屬性
     * @param def    默認值
     * @param <T>   物件型別
     * @param <R>   數字型別
     * @return  總和
     */
    public static <T, R extends Number> R sum(T[] array, Function<? super T, ? extends R> mapper, R def)
    {
        return sum(arrayToList(array), mapper, def);
    }

    // ------------------------------------------map------------------------------------------------------

    /**
     * 轉換集合型別
     * 如果集合為慷訓者是null
     * 回傳一個空集合
     * @param list  原集合
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> List<R> map(Collection<T> list, Function<? super T, ? extends R> mapper)
    {
        return isEmpty(list) ? new ArrayList<>() : list.stream().map(mapper).collect(Collectors.toList());
    }

    /**
     * 轉換陣列型別
     * 如果陣列為慷訓者是null
     * 回傳一個空集合
     * @param array  原陣列
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> List<R> map(T[] array, Function<? super T, ? extends R> mapper)
    {
        return map(arrayToList(array), mapper);
    }

    /**
     * 轉換集合型別
     * 如果集合為慷訓者是null
     * 回傳一個空HashSet集合
     * @param list  原集合
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> Set<R> mapSet(Collection<T> list, Function<? super T, ? extends R> mapper)
    {
        return isEmpty(list) ? new HashSet<>() : list.stream().map(mapper).collect(Collectors.toSet());
    }

    /**
     * 轉換陣列型別
     * 如果陣列為慷訓者是null
     * 回傳一個空HashSet集合
     * @param array  原陣列
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> Set<R> mapSet(T[] array, Function<? super T, ? extends R> mapper)
    {
        return mapSet(arrayToList(array), mapper);
    }

    // ------------------------------------------filterMap------------------------------------------------------

    /**
     * 根據條件篩選過集合后進行
     * 轉換集合型別
     * 如果集合為慷訓者是null
     * 回傳一個空集合
     * @param list  原集合
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> List<R> filterMap(Collection<T> list, Predicate<? super T> predicate, Function<? super T, ? extends R> mapper)
    {
        return isEmpty(list) ? new ArrayList<>() : list.stream().filter(predicate).map(mapper).collect(Collectors.toList());
    }

    /**
     * 根據條件篩選過陣列后進行
     * 轉換集合型別
     * 如果陣列為慷訓者是null
     * 回傳一個空集合
     * @param array  原陣列
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> List<R> filterMap(T[] array, Predicate<? super T> predicate, Function<? super T, ? extends R> mapper)
    {
        return filterMap(arrayToList(array), predicate, mapper);
    }

    /**
     * 根據條件篩選過集合后進行
     * 轉換集合型別
     * 如果集合為慷訓者是null
     * 回傳一個空集合
     * @param list  原集合
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> Set<R> filterMapSet(Collection<T> list, Predicate<? super T> predicate, Function<? super T, ? extends R> mapper)
    {
        return isEmpty(list) ? new HashSet<>() : list.stream().filter(predicate).map(mapper).collect(Collectors.toSet());
    }

    /**
     * 根據條件篩選過陣列后進行
     * 轉換集合型別
     * 如果陣列為慷訓者是null
     * 回傳一個空集合
     * @param array  原陣列
     * @param mapper    轉換規則
     * @param <T>
     * @param <R>
     * @return  轉換后的集合
     */
    public static <T, R> Set<R> filterMapSet(T[] array, Predicate<? super T> predicate, Function<? super T, ? extends R> mapper)
    {
        return filterMapSet(arrayToList(array), predicate, mapper);
    }

    // ------------------------------------------filterForeach------------------------------------------------------

    /**
     * 根據條件篩選過集合后進行操作
     * 空集合和 null,不進行操作
     * @param list          原集合
     * @param predicate     篩選規則
     * @param consumer      操作
     * @param <T>
     */
    public static <T> void filterForeach(Collection<T> list, Predicate<? super T> predicate, Consumer<T> consumer)
    {
        if (!isEmpty(list))
        {
            list.stream().filter(predicate).forEach(consumer);
        }
    }

    /**
     * 根據條件篩選過陣列后進行操作
     * 空陣列和 null,不進行操作
     * @param array          原陣列
     * @param predicate     篩選規則
     * @param consumer      操作
     * @param <T>
     */
    public static <T> void filterForeach(T[] array, Predicate<? super T> predicate, Consumer<T> consumer)
    {
        filterForeach(arrayToList(array), predicate, consumer);
    }


    // -----------------------------------私有方法--------------------------------------------------------------

    /**
     * 獲取集合中的最值
     * @param list  資料集合
     * @param def   默認值
     * @param isMax true:最大  false:最小
     * @param <T>
     * @return  最值
     */
    private static <T extends Comparable> T getMaxOrMin(Collection<T> list, T def, boolean isMax)
    {
        // 是否有默認值
        boolean isDef = Objects.nonNull(def);
        // 判斷集合是否為空
        if (isEmpty(list))
        {
            // 如果有默認值就回傳默認值
            if (isDef)
            {
                return def;
            }
            // 沒有默認值拋出例外
            throw new NoSuchElementException("Array為空,不存在最" + (isMax ? "大" : "小") + "值");
        }
        // 獲取流
        Stream<T> stream = list.stream();
        // 獲取最值
        Optional<T> number;
        if (isMax)
        {
            number = stream.max(Comparable::compareTo);
        }else {
            number = stream.min(Comparable::compareTo);
        }
        // 回傳最值
        return isDef ? number.orElse(def) : number.orElseThrow();
    }

    /**
     * 獲取集合總和
     * 支持int,long,float,double數字型別
     * @param list  集合資料
     * @param def   默認值
     * @param <T>
     * @return  總和
     */
    private static <T extends Number> T getSum(Collection<T> list, T def)
    {
        // 是否有默認值
        boolean isDef = Objects.nonNull(def);
        // 判斷集合是否為空
        if (isEmpty(list))
        {
            // 如果有默認值就回傳默認值
            if (isDef)
            {
                return def;
            }
            // 沒有默認值拋出例外
            throw new NoSuchElementException("資料為空沒有總和");
        }
        try
        {
            // 獲取資料總和
            Optional<T> sum = list.stream().reduce(StreamUtils::sum);
            // 有默認值,取值失敗使用默認值, 否則取值失敗拋出例外
            return isDef ? sum.orElse(def) : sum.orElseThrow();
        }
        catch (NumberFormatException e)
        {
            // 計算出錯
            if (isDef)
            {
                // 有默認值,回傳默認值
                return def;
            }
            // 否則繼續拋出例外
            throw new NoSuchElementException(e.getMessage());
        }
    }

    /**
     * 計算兩個數字之和
     * 支持int,long,float,double數字型別
     * @param number1
     * @param number2
     * @param <T>
     * @return  總和
     */
    private static <T extends Number> T sum(T number1, T number2)
    {
        try
        {
            Class<? extends Number> clazz = number1.getClass();
            if (clazz != number2.getClass())
            {
                throw new NumberFormatException("所需計算總和的數,型別不同");
            }
            return (T) filterLimitOne(clazz.getMethods(), methods -> "sum".equals(methods.getName())).invoke(null, number1, number2);
        }
        catch (Exception e)
        {
            throw new NumberFormatException(e.getMessage());
        }
    }

}