封装集合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
* @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 对象类型
* @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 对象类型
* @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 数据类型
* @return 获取到的对象
*/
public static <T> T filterLimitOne(T[] array, Predicate<? super T> predicate)
{
return filterLimitOne(arrayToList(array), predicate, null);
}
/**
* 获取集合中一个满足条件的数据
* 集合为空 OR 没有符合条件的数据
* 抛出异常
* @param list 数据数组
* @param predicate 过滤条件
* @param 数据类型
* @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 数据类型
* @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 数据类型
* @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 对象类型
* @param 条件类型
* @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 对象类型
* @param 条件类型
* @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 对象类型
* @param 条件类型
* @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 对象类型
* @param 条件类型
* @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 数字类型
* @return 总和
*/
public static <T extends Number> T sum(Collection<T> list)
{
return sum(list, null);
}
/**
* 计算数组中数据的总和
* 如果数组为空 OR 计算失败,抛出异常
* 支持int,long,float,double数字类型
* @param list 数字数组
* @param 数字类型
* @return 总和
*/
public static <T extends Number> T sum(T[] array)
{
return sum(array, null);
}
/**
* 计算集合中数据的总和
* 如果集合为空 OR 计算失败,返回默认值
* 支持int,long,float,double数字类型
* @param list 数字集合
* @param 数字类型
* @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 数字类型
* @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 对象类型
* @param 数字类型
* @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 对象类型
* @param 数字类型
* @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
* @param
* @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
* @param
* @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
* @param
* @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
* @param
* @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
* @param
* @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
* @param
* @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
* @param
* @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
* @param
* @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
*/
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
*/
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
* @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
* @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
* @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());
}
}
}