祝大家,牛年大吉,代码无Bug
后续如有好的想法,仍会继续优化
/**
* @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 没有符合条件的数据
* 返回一个null
* @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)
{
// 集合中如果存在null,如果不在集合流中过滤掉null值, Optional的flatMap会出现空指针异常
// return Optional.ofNullable(list).flatMap(l -> l.stream().filter(Objects::nonNull).filter(predicate).findFirst()).orElse(def);
return Optional.ofNullable(list).map(l -> l.stream().filter(predicate).findFirst().orElse(def)).orElse(def);
}
/**
* 获取数组中一个满足条件的数据
* 数组为空 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);
}
// ------------------------------------------判断集合中是否包含指定条件------------------------------------------------------
/**
* 判断条件里的元素，一个为 true，返回true
* @param list
* @param predicate
* @param <T>
* @return
*/
public static <T> boolean anyMatch(Collection<T> list, Predicate<? super T> predicate)
{
return list.stream().anyMatch(predicate);
}
/**
* 判断条件里的元素，所有的都为 true，返回true
* @param list
* @param predicate
* @param <T>
* @return
*/
public static <T> boolean allMatch(Collection<T> list, Predicate<? super T> predicate)
{
return list.stream().allMatch(predicate);
}
/**
* 判断条件里的元素，所有的都为 false，返回true
* @param list
* @param predicate
* @param <T>
* @return
*/
public static <T> boolean noneMatch(Collection<T> list, Predicate<? super T> predicate)
{
return list.stream().noneMatch(predicate);
}
// -----------------------------------私有方法--------------------------------------------------------------
/**
* 获取默认值
* 默认值不为null,返回默认值
* 否则抛出异常
* @param defaultValue 默认值
* @param errorMsg 异常信息
* @param <T> 数据类型
* @return 默认值
*/
private static <T> T getDefaultValue(T defaultValue, String errorMsg)
{
// 判断是否存在默认值
if (Objects.nonNull(defaultValue))
{
// 返回默认值
return defaultValue;
}
// 抛出异常
throw new NoSuchElementException(errorMsg);
}
/**
* 获取集合中的最值
* @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)
{
// 判断集合是否为空
if (isEmpty(list))
{
return getDefaultValue(def, "Array为空,不存在最" + (isMax ? "大" : "小") + "值");
}
// 获取流
Stream<T> stream = list.stream();
// 获取最值
Optional<T> number;
if (isMax)
{
number = stream.max(Comparable::compareTo);
}else {
number = stream.min(Comparable::compareTo);
}
// 返回最值
return number.orElse(Optional.ofNullable(def).orElseThrow());
}
/**
* 获取集合总和
* 支持int,long,float,double数字类型
* @param list 集合数据
* @param def 默认值
* @param <T>
* @return 总和
*/
private static <T extends Number> T getSum(Collection<T> list, T def)
{
// 判断集合是否为空
if (isEmpty(list))
{
return getDefaultValue(def, "数据为空没有总和");
}
try
{
// 获取数据总和
Optional<T> sum = list.stream().reduce(StreamUtils::sum);
// 有默认值,取值失败使用默认值, 否则取值失败抛出异常
return sum.orElse(Optional.ofNullable(def).orElseThrow());
}
catch (NumberFormatException e)
{
return getDefaultValue(def, 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("所需计算总和的数,类型不同");
}
// 获取clazz对象中的sum方法
return (T) filterLimitOne(clazz.getMethods(), methods -> "sum".equals(methods.getName()))
//调用sum方法
.invoke(null, number1, number2);
}
catch (Exception e)
{
throw new NumberFormatException(e.getMessage());
}
}
}
扫一扫
3129
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
