众所周知，jdk8提供的Lambda表达式能帮我极大的精简代码，但是就在我们在实际使用过程中会有一些重复性的代码，比如对于stream来源的空判断处理，今天我就给大家整理了一些工具类，帮助大家更好的使用流
public final class EnhanceStream {
public static <t> List<t> singletonList(T o) {
return Collections.singletonList(o);
}
/**
* 生成list
*
* @param elements
* 元素
* @param <t>
* 泛型
* @return List
*/
@SafeVarargs
public static <t> List<t> toList(T... elements) {
List<t> list = new ArrayList<>();
if (Objects.nonNull(elements)) {
for (T element : elements) {
if (Objects.nonNull(element)) {
list.add(element);
}
}
}
return list;
}
public static <t> void addAll(Collection<t> collection, Collection<t> add) {
if (isNotEmpty(add)) {
collection.addAll(add);
}
}
/**
* 两个Map进行合并
*
* @param map
* 原始map
* @param add
* 要合并的map
* @param <k>
* key泛型
* @param <v>
* 值泛型
*/
public static <k, v> void addAll(Map<k, v> map, Map<k, v> add) {
if (isNotEmpty(add) && Objects.nonNull(map)) {
for (Map.Entry<k, v> kvEntry : add.entrySet()) {
map.put(kvEntry.getKey(), kvEntry.getValue());
}
}
}
public static <t> List<t> setToList(Set<t> set) {
if (EnhanceStream.isNotEmpty(set)) {
return new ArrayList<>(set);
} else {
return EnhanceStream.emptyList();
}
}
public static boolean isEmpty(final Collection<?> coll) {
return coll == null || coll.isEmpty();
}
/**
* Null-safe check if the specified collection is not empty.
* <p>
* Null returns false.
*
* @param coll
* the collection to check, may be null
* @return true if non-null and non-empty
* @since 3.2
*/
public static boolean isNotEmpty(final Collection<?> coll) {
return !isEmpty(coll);
}
public static boolean isEmpty(final Map<?, ?> map) {
return map == null || map.isEmpty();
}
public static boolean isNotEmpty(final Map<?, ?> map) {
return !isEmpty(map);
}
/**
* 返回空集合
*
* @param <t>
* 泛型
* @return List
*/
public static <t> List<t> emptyList() {
return Collections.emptyList();
}
public static final <k, v> Map<k, v> emptyMap() {
return Collections.emptyMap();
}
/**
* 返回空集合
*
* @param <t>
* 泛型
* @return List
*/
public static <t> Set<t> emptySet() {
return Collections.emptySet();
}
/**
* 去重
*
* @param dataSources
* 数据
* @param <t>
* 泛型
* @return List<t>
*/
public static <t> List<t> distinct(List<t> dataSources) {
return newStream(dataSources).filter(Objects::nonNull).distinct().collect(Collectors.toList());
}
/**
* 去重
*
* @param dataSources
* 数据
* @param <t>
* 泛型
* @return List<t>
*/
public static <t, r> List<r> distinct(List<t> dataSources, Function<t, r> mapper) {
List<r> rs = mapToList(dataSources, mapper);
return newStream(rs).filter(Objects::nonNull).distinct().collect(Collectors.toList());
}
/**
* 去重
*
* @param dataSources
* 数据
* @param <t>
* 泛型
* @return List<t>
*/
public static <t, t1, r> List<r> distinct(List<t> dataSources, Function<t, t1> mapper1, Function<t1, r> mapper2) {
List<t1> rs = mapToList(dataSources, mapper1);
return newStream(rs).filter(Objects::nonNull).map(mapper2).distinct().collect(Collectors.toList());
}
/**
* 去重
*
* @param dataSources
* 数据
* @param <t>
* 泛型
* @return List<t>
*/
public static <t, r> List<t> distinctByKey(List<t> dataSources, Function<t, r> mapper) {
Map<r, t> dismantling = dismantlingFirst(dataSources, mapper);
return getValues(dismantling);
}
/**
* 从流中获取Inter类型数据,非空处理后,求和
*
* @param dataStream
* 原始数据流
* @param mapper
* 指定数字类型字段
* @param <t>
* 泛型
* @return Integer
*/
public static <t> Integer mapToNonNullIntSum(Stream<t> dataStream, Function<t, integer> mapper) {
List<integer> integers = mapToList(dataStream, mapper);
int total = 0;
for (Integer integer : integers) {
if (Objects.nonNull(integer)) {
total += integer;
}
}
return total;
}
/**
* 从流中获取Inter类型数据,非空处理后,求和（如果元素为空，则返回空）
*
* @param dataStream
* 原始数据流
* @param mapper
* 指定数字类型字段
* @param <t>
* 泛型
* @return Integer
*/
public static <t> Integer mapToNullAbleIntSum(Stream<t> dataStream, Function<t, integer> mapper) {
List<integer> integers = mapToList(dataStream, mapper);
int total = 0;
boolean haveNonNull = false;
for (Integer integer : integers) {
if (Objects.nonNull(integer)) {
haveNonNull = true;
total += integer;
}
}
return haveNonNull ? total : null;
}
/**
* 从流中获取Inter类型数据,非空处理后,求和
*
* @param dataStream
* 原始数据流
* @param mapper
* 指定数字类型字段
* @param <t>
* 泛型
* @return Integer
*/
public static <t> Long mapToNonNullLongSum(Stream<t> dataStream, Function<t, long> mapper) {
List<long> longs = mapToList(dataStream, mapper);
long total = 0;
for (Long nextLong : longs) {
if (Objects.nonNull(nextLong)) {
total += nextLong;
}
}
return total;
}
/**
* 从流中获取Inter类型数据,非空处理后,求和
*
* @param dataSources
* 原始数据源
* @param mapper
* 指定数字类型字段
* @param <t>
* 泛型
* @return Integer
*/
public static <t> Integer mapToNonNullIntSum(List<t> dataSources, Function<t, integer> mapper) {
return mapToNonNullIntSum(newStream(dataSources), mapper);
}
/**
* 从流中获取Inter类型数据,非空处理后,求和（如果元素为空，则返回空）
*
* @param dataSources
* 原始数据源
* @param mapper
* 指定数字类型字段
* @param <t>
* 泛型
* @return Integer
*/
public static <t> Integer mapToNullAbleIntSum(List<t> dataSources, Function<t, integer> mapper) {
return mapToNullAbleIntSum(newStream(dataSources), mapper);
}
/**
* 从流中获取Inter类型数据,非空处理后,求和
*
* @param dataSources
* 原始数据源
* @param mapper
* 指定数字类型字段
* @param <t>
* 泛型
* @return Integer
*/
public static <t> Long mapToNonNullLongSum(List<t> dataSources, Function<t, long> mapper) {
return mapToNonNullLongSum(newStream(dataSources), mapper);
}
/**
* 从map中获取所有的值的list
*
* @param map
* Map数据
* @param <k>
* key泛型
* @param <v>
* value泛型
* @return List
*/
public static <k, v> List<v> getValues(Map<k, v> map) {
if (CollectionUtils.isEmpty(map)) {
return Collections.emptyList();
}
Collection<v> values = map.values();
return new ArrayList<>(values);
}
/**
* 从map中获取所有的值的list
*
* @param map
* Map数据
* @param <k>
* key泛型
* @param <v>
* value泛型
* @return List
*/
public static <k, v> Optional<v> getValuesFirst(Map<k, v> map) {
List<v> values = getValues(map);
return values.stream().findFirst();
}
/**
* 如果是数据分组格式key是一个，value是list的情况，只去value中的第一个。
*
* @param map
* Map数据
* @param <k>
* key泛型
* @param <v>
* value泛型
* @return List
*/
public static <k, v> List<v> eachGetValueFirst(Map<k, list<v>> map) {
if (CollectionUtils.isEmpty(map)) {
return Collections.emptyList();
}
List<v> result = new ArrayList<>(map.size());
for (Map.Entry<k, list<v>> entry : map.entrySet()) {
if (!CollectionUtils.isEmpty(entry.getValue())) {
result.add(entry.getValue().get(0));
}
}
return result;
}
/**
* 从map中获取所有的key的list
*
* @param map
* Map数据
* @param <k>
* key泛型
* @param <v>
* value泛型
* @return List
*/
public static <k, v> List<k> getKeys(Map<k, v> map) {
if (CollectionUtils.isEmpty(map)) {
return Collections.emptyList();
}
Set<k> ks = map.keySet();
return new ArrayList<>(ks);
}
/**
* 从流中建立新的类型
*
* @param dataStream
* 数据流
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> List<r> mapToList(Stream<t> dataStream, Function<t, r> mapping) {
return newStream(dataStream).map(mapping).filter(Objects::nonNull).collect(Collectors.toList());
}
/**
* 从流中建立新的类型
*
* @param dataSources
* 数据源
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> List<r> mapToList(List<t> dataSources, Function<t, r> mapping) {
return newStream(dataSources).map(mapping).filter(Objects::nonNull).collect(Collectors.toList());
}
/**
* 从流中建立新的类型
*
* @param dataSources
* 数据源
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> List<r> mapToUniqueList(List<t> dataSources, Function<t, r> mapping) {
return newStream(dataSources).map(mapping).filter(Objects::nonNull).distinct().collect(Collectors.toList());
}
/**
* 从流中建立新的类型
*
* @param dataSources
* 数据源
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r1, r> List<r> mapToUniqueList(List<t> dataSources, Function<t, r1> mapping,
Function<r1, r> mapping1) {
return newStream(dataSources).map(mapping).filter(Objects::nonNull).map(mapping1).filter(Objects::nonNull)
.distinct().collect(Collectors.toList());
}
/**
* 从流中建立新的类型
*
* @param dataSources
* 数据源
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r, v> List<v> supperMapToList(List<t> dataSources, Function<t, r> mapping,
Function<r, v> mapping2) {
return newStream(dataSources).map(mapping).filter(Objects::nonNull).map(mapping2).filter(Objects::nonNull)
.distinct().collect(Collectors.toList());
}
/**
* 将多个list集合合并成一个 如果要保证添加顺序，请按照顺序添加
*
* @param dataSourceList
* 数据源
* @return List
*/
@SafeVarargs
public static <t> List<t> mergeList(List<t>... dataSourceList) {
if (Objects.isNull(dataSourceList)) {
return emptyList();
}
List<t> result = new ArrayList<>();
for (List<t> ts : dataSourceList) {
if (isNotEmpty(ts)) {
result.addAll(ts);
}
}
return result;
}
/**
* 从流中建立新的List类型,并将新的list
*
* @param dataSources
* 数据源
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> List<r> mapToMergeList(List<t> dataSources, Function<t, list<r>> mapping) {
List<list<r>> collect =
newStream(dataSources).map(mapping).filter(Objects::nonNull).collect(Collectors.toList());
List<r> allList = new ArrayList<>();
for (List<r> rs : collect) {
allList.addAll(rs);
}
return allList;
}
/**
* 从流中建立新的类型
*
* @param dataSource
* 数据
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> Set<r> mapToSet(List<t> dataSource, Function<t, r> mapping) {
return newStream(dataSource).map(mapping).filter(Objects::nonNull).collect(Collectors.toSet());
}
/**
* 从流中建立新的类型
*
* @param dataStream
* 数据流
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> Set<r> mapToSet(Stream<t> dataStream, Function<t, r> mapping) {
return newStream(dataStream).map(mapping).filter(Objects::nonNull).collect(Collectors.toSet());
}
/**
* 从流中建立新的类型并去重
*
* @param dataSources
* 数据流
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> List<r> distinctMapToList(List<t> dataSources, Function<t, r> mapping) {
return newStream(newStream(dataSources)).map(mapping).filter(Objects::nonNull).distinct()
.collect(Collectors.toList());
}
/**
* 从流中建立新的类型并去重
*
* @param dataStream
* 数据流
* @param mapping
* 转换函数
* @param <t>
* 原数据类型
* @param <r>
* 目标数据类型
* @return List
*/
public static <t, r> List<r> distinctMapToList(Stream<t> dataStream, Function<t, r> mapping) {
return newStream(dataStream).map(mapping).filter(Objects::nonNull).distinct().collect(Collectors.toList());
}
/**
* 对数据流进行过滤
*
* @param dataStream
* 数据流
* @param predicate
* 过滤条件
* @param exceptionSupplier
* 异常生成
* @param <t>
* 数据泛型
* @param <x>
* 异常泛型
* @return List 过滤后的数据条件
* @throws X
* Throwable
*/
public static <t, x extends throwable> T filterSingle(Stream<t> dataStream, Predicate<? super T> predicate,
Supplier<? extends X> exceptionSupplier) throws X {
return StreamFilter.filterSingle(newStream(dataStream), predicate, exceptionSupplier);
}
/**
* 过滤
*
* @param dataSource
* 数据源
* @param predicate
* 过滤条件
* @param <t>
* 数据泛型
* @return List
*/
public static <t, r> List<t> superFilter(List<t> dataSource, Function<t, r> function,
Predicate<? super R> predicate) {
return superFilter(newStream(dataSource), function, predicate);
}
/**
* 根据条件生成List集合
*
* @param dataStream
* 数据流
* @param predicate
* 过滤条件
* @param <t>
* 数据泛型
* @return List
*/
public static <t, r> List<t> superFilter(Stream<t> dataStream, Function<t, r> function,
Predicate<? super R> predicate) {
List<t> result = new ArrayList<>();
dataStream.filter(Objects::nonNull).forEach(t -> {
R apply = function.apply(t);
if (predicate.test(apply)) {
result.add(t);
}
});
return result;
}
/**
* 对数据流进行过滤
*
* @param dataSource
* 数据源头
* @param predicate
* 过滤条件
* @param <t>
* 数据泛型
* @return List 过滤后的数据条件
*/
public static <t> List<t> filter(List<t> dataSource, Predicate<? super T> predicate) {
return StreamFilter.filter(newStream(dataSource), predicate);
}
/**
* 对数据流进行过滤
*
* @param dataStream
* 数据流
* @param predicate
* 过滤条件
* @param <t>
* 数据泛型
* @return List 过滤后的数据条件
*/
public static <t> List<t> filter(Stream<t> dataStream, Predicate<? super T> predicate) {
return StreamFilter.filter(newStream(dataStream), predicate);
}
public static <t, x extends throwable> T findFirst(Stream<t> dataStream, Supplier<? extends X> exceptionSupplier)
throws X {
return newStream(dataStream).findFirst().orElseThrow(exceptionSupplier);
}
public static <t> Optional<t> findFirst(Stream<t> dataStream) {
return newStream(dataStream).findFirst();
}
public static <t> Optional<t> findFirst(List<t> dataList) {
return newStream(dataList).findFirst();
}
public static <t> Optional<t> findAny(Stream<t> dataStream) {
return newStream(dataStream).findAny();
}
/**
* 从流中获取任意数据
*
* @param dataList
* 数据集合
* @param <t>
* 泛型
* @return Optional
*/
public static <t> Optional<t> findAny(List<t> dataList) {
return newStream(dataList).findAny();
}
/**
* 从流中获取任意数据
*
* @param dataList
* 数据集合
* @param <t>
* 泛型
* @return Optional
*/
public static <t> T findRequiredAny(List<t> dataList) {
Optional<t> any = newStream(dataList).findAny();
if (!any.isPresent()) {
throw new RuntimeException("EnhanceStream.findRequiredAny:"+dataList);
}
return any.get();
}
/**
* 对数据流进行过滤,并对过滤后的数据进行类型转换
*
* @param dataStream
* 数据流
* @param predicate
* 过滤条件
* @param applyMapping
* 数据转换器
* @param <t>
* 数据泛型
* @param <v>
* 转换后的数据类型
* @return List 过滤后的数据条件
*/
public static <t, v> List<v> filter(Stream<t> dataStream, Predicate<? super T> predicate,
Function<? super T, ? extends V> applyMapping) {
return StreamFilter.filter(newStream(dataStream), predicate, applyMapping);
}
/**
* 对数据流进行分组
*
* @param dataStream
* 数据流
* @param keyApply
* 分组项
* @param <t>
* 数据泛型
* @param <k>
* 分组项泛型
* @return Map 分组后数据
*/
public static <t, k> Map<k, list<t>> group(Stream<t> dataStream, Function<? super T, ? extends K> keyApply) {
return StreamBinder.group(newStream(dataStream), keyApply);
}
/**
* 对数据流进行分组,并对分组后的数据进行类型转换
*
* @param dataStream
* 数据流
* @param keyApply
* 分组项
* @param valueApply
* 数据转换器
* @param <t>
* 数据泛型
* @param <k>
* 分组项泛型
* @param <v>
* 转换后的数据类型
* @return Map 分组后数据
*/
public static <t, k, v> Map<k, list<v>> group(Stream<t> dataStream, Function<? super T, ? extends K> keyApply,
Function<? super T, ? extends V> valueApply) {
return StreamBinder.group(newStream(dataStream), keyApply, valueApply);
}
/**
* @param dataSource
* 商品配置
* @param keyApply
* key生成
* @param <k>
* key泛型
* @param <t>
* 数据源泛型
* @return Map<k, v>
*/
public static <k, t> Map<k, t> dismantlingFirst(List<t> dataSource, Function<? super T, ? extends K> keyApply) {
return StreamBinder.dismantlingFirst(newStream(dataSource), keyApply);
}
/**
* @param dataSource
* 商品配置
* @param keyApply
* key生成
* @param <k>
* key泛型
* @param <t>
* 数据源泛型
* @return Map<k, v>
*/
public static <k, v,t> Map<k, v> dismantlingFirst(List<t> dataSource, Function<? super T, ? extends K> keyApply,Function<? super T, ? extends V> valueApply) {
return StreamBinder.dismantlingFirst(newStream(dataSource), keyApply,valueApply);
}
/**
* @param dataSourceStream
* 商品配置
* @param keyApply
* key生成
* @param <k>
* key泛型
* @param <t>
* 数据源泛型
* @return Map<k, v>
*/
public static <k, t> Map<k, t> dismantlingFirst(Stream<t> dataSourceStream,
Function<? super T, ? extends K> keyApply) {
return StreamBinder.dismantlingFirst(dataSourceStream, keyApply);
}
/**
* 数据拆分「注意: 拆分后的数据,如果Key一样会产生异常,请谨慎使用
*
* @param dataStream
* 数据流
* @param keyApply
* Key转换器
* @param <t>
* 原始数据泛型
* @param <k>
* Key泛型
* @return Map 拆分后数据
*/
public static <t, k> Map<k, t> dismantling(List<t> dataStream, Function<? super T, ? extends K> keyApply) {
return StreamBinder.dismantling(newStream(dataStream), keyApply);
}
/**
* 数据拆分「注意: 拆分后的数据,如果Key一样会产生异常,请谨慎使用
*
* @param dataStream
* 数据流
* @param keyApply
* Key转换器
* @param <t>
* 原始数据泛型
* @param <k>
* Key泛型
* @return Map 拆分后数据
*/
public static <t, k> Map<k, t> dismantling(Stream<t> dataStream, Function<? super T, ? extends K> keyApply) {
return StreamBinder.dismantling(newStream(dataStream), keyApply);
}
/**
* 数据拆分「注意: 拆分后的数据,如果Key一样会产生异常,请谨慎使用
*
* @param dataSource
* 数据源
* @param keyApply
* Key转换器
* @param <t>
* 原始数据泛型
* @param <k>
* Key泛型
* @return Map 拆分后数据
*/
public static <t, k, x extends throwable> Map<k, t> dismantling(List<t> dataSource,
Function<? super T, ? extends K> keyApply, Supplier<? extends X> exceptionSupplier) throws X {
return StreamBinder.dismantling(newStream(dataSource), keyApply, exceptionSupplier);
}
/**
* 数据拆分「注意: 拆分后的数据,如果Key一样会产生异常,请谨慎使用
*
* @param dataStream
* 数据流
* @param keyApply
* Key转换器
* @param <t>
* 原始数据泛型
* @param <k>
* Key泛型
* @return Map 拆分后数据
*/
public static <t, k, x extends throwable> Map<k, t> dismantling(Stream<t> dataStream,
Function<? super T, ? extends K> keyApply, Supplier<? extends X> exceptionSupplier) throws X {
return StreamBinder.dismantling(newStream(dataStream), keyApply, exceptionSupplier);
}
/**
* 数据拆分「注意: 拆分后的数据,如果Key一样会产生异常,请谨慎使用
*
* @param dataStream
* 数据流
* @param keyApply
* Key转换器
* @param valueApply
* Value转换器
* @param <t>
* 原始数据泛型
* @param <k>
* Key泛型
* @param <v>
* Value泛型
* @return Map 拆分后数据
*/
public static <t, k, v> Map<k, v> dismantling(Stream<t> dataStream, Function<? super T, ? extends K> keyApply,
Function<? super T, ? extends V> valueApply) {
return StreamBinder.dismantling(newStream(dataStream), keyApply, valueApply);
}
/**
* 数据拆分「注意: 拆分后的数据,如果Key一样会产生异常,请谨慎使用
*
* @param dataStream
* 数据流
* @param keyApply
* Key转换器
* @param valueApply
* Value转换器
* @param <t>
* 原始数据泛型
* @param <k>
* Key泛型
* @param <v>
* Value泛型
* @param <x>
* 数据重复产生的异常描述
* @return Map 拆分后数据
*/
public static <t, k, v, x extends throwable> Map<k, v> dismantling(Stream<t> dataStream,
Function<? super T, ? extends K> keyApply, Function<? super T, ? extends V> valueApply,
Supplier<? extends X> exceptionSupplier) throws X {
return StreamBinder.dismantling(newStream(dataStream), keyApply, valueApply, exceptionSupplier);
}
private static <t> Stream<t> newStream(Stream<t> dataSourcesStream) {
if (dataSourcesStream == null) {
return Stream.empty();
}
return dataSourcesStream;
}
public static <t> Stream<t> newStream(List<t> dataSources) {
if (dataSources == null) {
return Stream.empty();
}
return dataSources.stream();
}
/**
* 对数据流进行过滤,并对过滤后的数据进行类型转换
*
* @param dataSources
* 原始数据流
* @param predicate
* 过滤条件
* @param applyMapping
* 数据转换器
* @param <v>
* 转换后的数据类型
* @param <t>
* 原始数据类型
* @return List 过滤后的数据条件
*/
public static <t, v> List<v> filter(List<t> dataSources, Predicate<? super T> predicate,
Function<? super T, ? extends V> applyMapping) {
return StreamFilter.filter(newStream(dataSources), predicate, applyMapping);
}
/**
* 数据拆分「注意: 拆分后的数据,如果Key一样会产生异常,请谨慎使用
*
* @param dataSources
* 原始数据
* @param keyApply
* Key转换器
* @param valueApply
* Value转换器
* @param <k>
* Key泛型
* @param <v>
* Value泛型
* @param <t>
* 原始数据类型
* @return Map 拆分后数据
*/
public static <t, k, v> Map<k, v> dismantling(List<t> dataSources, Function<? super T, ? extends K> keyApply,
Function<? super T, ? extends V> valueApply) {
return StreamBinder.dismantling(newStream(dataSources), keyApply, valueApply);
}
public static <t> void removeIf(List<t> dataSources, Predicate<t> predicate) {
if (Objects.nonNull(dataSources) && !dataSources.isEmpty()) {
dataSources.removeIf(predicate);
}
}
public static <t> void removeNotIf(List<t> dataSources, Predicate<t> predicate) {
if (Objects.nonNull(dataSources) && !dataSources.isEmpty()) {
dataSources.removeIf(t -> !predicate.test(t));
}
}
/**
* 对数据流进行分组
*
* @param dataSources
* 原始数据流
* @param keyApply
* 分组项
* @param <k>
* 分组项泛型
* @return Map 分组后数据
*/
public static <k, t> Map<k, list<t>> group(List<t> dataSources, Function<? super T, ? extends K> keyApply) {
return StreamBinder.group(newStream(dataSources), keyApply);
}
/**
* 对数据流进行分组,并对分组后的数据进行类型转换
*
* @param dataSources
* 原始数据流
* @param keyApply
* 分组项
* @param valueApply
* 数据转换器
* @param <k>
* 分组项泛型
* @param <v>
* 转换后的数据类型
* @return Map 分组后数据
*/
public static <k, t, v> Map<k, list<v>> group(List<t> dataSources, Function<? super T, ? extends K> keyApply,
Function<? super T, ? extends V> valueApply) {
return StreamBinder.group(newStream(dataSources), keyApply, valueApply);
}
/**
* 升序
*
* @param dataSources
* 数据集合
* @param compareFunction
* 排序字段
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedAsc(List<t> dataSources,
Function<t, u> compareFunction) {
return sorted(newStream(dataSources), compareFunction, SortStrategy.UP, SortNullStrategy.NULL_IGNORE);
}
/**
* 升序
*
* @param dataStream
* 数据集合
* @param compareFunction
* 排序字段
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedAsc(Stream<t> dataStream,
Function<t, u> compareFunction) {
return sorted(dataStream, compareFunction, SortStrategy.UP, SortNullStrategy.NULL_IGNORE);
}
/**
* 升序
*
* @param dataSources
* 数据集合
* @param compareFunction
* 排序字段
* @param sortNullStrategy
* 排序控制策略
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedAsc(List<t> dataSources,
Function<t, u> compareFunction, SortNullStrategy sortNullStrategy) {
return sorted(newStream(dataSources), compareFunction, SortStrategy.UP, sortNullStrategy);
}
/**
* 升序
*
* @param dataStream
* 数据集合
* @param compareFunction
* 排序字段
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedAsc(Stream<t> dataStream,
Function<t, u> compareFunction, SortNullStrategy sortNullStrategy) {
return sorted(dataStream, compareFunction, SortStrategy.UP, sortNullStrategy);
}
/**
* 降序
*
* @param dataSources
* 数据集合
* @param compareFunction
* 排序字段
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedDesc(List<t> dataSources,
Function<t, u> compareFunction) {
return sorted(newStream(dataSources), compareFunction, SortStrategy.DOWN, SortNullStrategy.NULL_IGNORE);
}
/**
* 降序
*
* @param dataStream
* 数据集合
* @param compareFunction
* 排序字段
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedDesc(Stream<t> dataStream,
Function<t, u> compareFunction) {
return sorted(dataStream, compareFunction, SortStrategy.DOWN, SortNullStrategy.NULL_IGNORE);
}
/**
* 降序
*
* @param dataSources
* 数据集合
* @param compareFunction
* 排序字段
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedDesc(List<t> dataSources,
Function<t, u> compareFunction, SortNullStrategy sortNullStrategy) {
return sorted(newStream(dataSources), compareFunction, SortStrategy.DOWN, sortNullStrategy);
}
/**
* 降序
*
* @param dataStream
* 数据集合
* @param compareFunction
* 排序字段
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
public static <t, u extends comparable<? super>> List<t> sortedDesc(Stream<t> dataStream,
Function<t, u> compareFunction, SortNullStrategy sortNullStrategy) {
return sorted(dataStream, compareFunction, SortStrategy.DOWN, sortNullStrategy);
}
private enum SortStrategy {
/**
* 升序
*/
UP,
/**
* 降序
*/
DOWN;
}
public enum SortNullStrategy {
/**
* 如果值为空就忽略
*/
NULL_IGNORE,
/**
* 值为空就放最后
*/
NULL_LAST,
/**
* 值为空就放前面
*/
NULL_FIRST;
}
/**
* @param dataStream
* 数据集合
* @param compareFunction
* 排序字段
* @param sortStrategy
* 排序策略
* @param sortStrategy
* true报异常
* @param <t>
* 集合类型泛型类
* @return List<t>
*/
private static <t, u extends comparable<? super>> List<t> sorted(Stream<t> dataStream,
Function<t, u> compareFunction, SortStrategy sortStrategy, SortNullStrategy sortNullStrategy) {
Comparator<t> comparing;
if (Objects.isNull(sortStrategy) || SortStrategy.UP == sortStrategy) {
if (sortNullStrategy == SortNullStrategy.NULL_LAST) {
comparing = Comparator.comparing(compareFunction, Comparator.nullsLast(U::compareTo));
} else if (sortNullStrategy == SortNullStrategy.NULL_FIRST) {
comparing = Comparator.comparing(compareFunction, Comparator.nullsFirst(U::compareTo));
} else {
comparing = Comparator.comparing(compareFunction);
}
} else {
if (sortNullStrategy == SortNullStrategy.NULL_LAST) {
comparing = Comparator.comparing(compareFunction, Comparator.nullsLast(U::compareTo).reversed());
} else if (sortNullStrategy == SortNullStrategy.NULL_FIRST) {
comparing = Comparator.comparing(compareFunction, Comparator.nullsFirst(U::compareTo).reversed());
} else {
comparing = Comparator.comparing(compareFunction, Comparator.reverseOrder());
}
}
return dataStream.sorted(comparing).collect(Collectors.toList());
}
public static <t> boolean contains(T[] dataSources, T... elements) {
return contains(Stream.of(dataSources), elements);
}
public static <t> boolean containsAny(T[] dataSources, T... elements) {
return containsAny(Stream.of(dataSources), elements);
}
public static <t> boolean contains(List<t> dataSource, T... elements) {
return contains(newStream(dataSource), elements);
}
public static <t> boolean containsAny(List<t> dataSource, T... elements) {
return containsAny(newStream(dataSource), elements);
}
public static <t> boolean contains(Stream<t> dataStream, T... elements) {
List<t> ts = mapToList(newStream(dataStream), Function.identity());
if (Objects.isNull(elements)) {
return false;
}
for (T element : elements) {
if (!ts.contains(element)) {
return false;
}
}
return true;
}
public static <t> boolean containsAny(Stream<t> dataStream, T... elements) {
List<t> ts = mapToList(dataStream, Function.identity());
if (Objects.isNull(elements)) {
return false;
}
for (T element : elements) {
if (ts.contains(element)) {
return true;
}
}
return false;
}
@SafeVarargs
public static <t, r> List<r> merge(Function<t, r> mapper, List<t>... lists) {
List<r> result = new ArrayList<>();
for (R r : distinct(lists[0], mapper)) {
boolean temp = true;
for (int i = 1; i < lists.length; i++) {
List<r> rs = EnhanceStream.distinct(lists[i], mapper);
Map<r, r> reMapping = EnhanceStream.dismantling(rs, Function.identity());
if (Objects.isNull(reMapping.get(r))) {
temp = false;
}
}
if (temp) {
result.add(r);
}
}
return EnhanceStream.distinct(result);
}
public static <t> T[] listToArr(List<t> dataList) {
return (T[])dataList.toArray(new Object[0]);
}
public static <t> List<t> arrToList(T[] dataList) {
return Stream.of(dataList).collect(Collectors.toList());
}
</t></t></t></t></r,></r></r></t></t,></r></t,></t></t></t></t></t></t></t></t></t></t></t></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t,></t></t></t></k,></k,></v></k></t></k,></k,></k></t></t></t></t></t></t></t></k,></t,></t></v></k></t></v></t,></t></v></t></t></t></t></t></t></t></k,></t,></x></v></k></t></t></k,></t,></v></k></t></t></k,></t,></k></t></t></k,></t,></k></t></t></k,></t,></k></t></t></k,></t,></k></t></t></k,></k,></k,></t></k></t></k,></k,></k,></t></k></t></k,></k,></k,></t></k></t></k,></t,></v></k></t></t></k,></t,></k></t></t></v></t,></v></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t></t,></t></t></t></t></t></t></t></t></t></t,></t></t></t,></t></t,></t></t></t,></t></t></t,></x></t></t,></t></r></t,></r></t></t,></t></r></t,></r></t></t,></t></r></t,></r></t></t,></t></r></t,></r></t></r></r></list<r></t,></t></r></t,></r></t></t></t></t></t></t></r,></t,></t></v></t,></r></t></r1,></t,></t></r></t,></r></t></t,></t></r></t,></r></t></t,></t></r></t,></r></t></t,></t></r></t,></r></t></k></k,></k></k,></v></k></k,></v></k,></v></k,></v></k></v></k,></v></k,></v></k></v></k,></v></k,></v></k></t,></t></t></t></t,></t></t></t></t,></t></t></t></long></t,></t></t></t></integer></t,></t></t></t></integer></t,></t></t></t></r,></t,></t></t></t,></t></t></t1></t1,></t,></t></r></t,></t></t></r></t,></t></r></t,></t></t></t></t></t></t></t></t></t></t></k,></k,></t></t></t></p></t></t></t></k,></k,></k,></k,></v></k></t></t></t></t></t></t></t></t></t>
}
有兴趣可以一起交流工具类,请关注我得公众号
往事随风、无忧无恼
Original: https://www.cnblogs.com/qiuzhiqiang/p/16026527.html
Author: 邱志强
Title: Lambda表达式工具类-日常搬砖
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/570538/
转载文章受原作者版权保护。转载请注明原作者出处！