最近发现代码里面大量处理集合的lambda表达式,所以想着封装个常用工具类,用来快速调用,直接贴代码
只需传入集合,Function,Predicate,Comparator等即可。上手简单,让代码更简洁。
package com.example.declaration.util;
import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.stream.Collectors;
/**
* @Author ZhuZiKai
* @Description 封装Lambda常用方法
* @date 2021/12/14 10:08
*/
public class LambdaUtil {
/**
* 通过条件分组
*
* @param list
* @param func
* @param <T>
* @param <R>
* @return
*/
public static <T, R> Map<R, List<T>> groupingBy(List<T> list, Function<T, R> func) {
return Optional.ofNullable(list)
.map(l -> l.stream().collect(Collectors.groupingBy(func, Collectors.toList())))
.orElse(new HashMap<>());
}
/**
* 以自身为value的map
*
* @param list
* @param keyFunc
* @param valueFunc
* @param <R>
* @param <T>
* @return
*/
public static <R, T> Map<R, T> toIdentityMap(List<T> list, Function<T, R> keyFunc, Function<T, T> valueFunc) {
return Optional.ofNullable(list)
.map(l -> l.stream().collect(Collectors.toMap(keyFunc, valueFunc)))
.orElse(new HashMap<>());
}
/**
* 以String为value的map
*
* @param list
* @param keyFunc
* @param valueFunc
* @param <R>
* @param <T>
* @return
*/
public static <R, T> Map<R, String> toStringMap(List<T> list, Function<T, R> keyFunc, Function<T, String> valueFunc) {
return Optional.ofNullable(list)
.map(l -> l.stream().collect(Collectors.toMap(keyFunc, valueFunc)))
.orElse(new HashMap<>());
}
/**
* 以integer为value的map
*
* @param list
* @param keyFunc
* @param valueFunc
* @param <R>
* @param <T>
* @return
*/
public static <R, T> Map<R, Integer> toIntegerMap(List<T> list, Function<T, R> keyFunc, Function<T, Integer> valueFunc) {
return Optional.ofNullable(list)
.map(l -> l.stream().collect(Collectors.toMap(keyFunc, valueFunc)))
.orElse(new HashMap<>());
}
/**
* 获取某个字段list
*
* @param list
* @param func
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<R> map(List<T> list, Function<T, R> func) {
return Optional.ofNullable(list)
.map(l -> l.stream().map(func).collect(Collectors.toList()))
.orElse(new ArrayList<>());
}
public static <T, R> List<R> map(Set<T> list, Function<T, R> func) {
return Optional.ofNullable(list)
.map(l -> l.stream().map(func).collect(Collectors.toList()))
.orElse(new ArrayList<>());
}
/**
* double求和
*
* @param list
* @param func
* @param <T>
* @return
*/
public static <T> Double doubleSum(List<T> list, ToDoubleFunction<T> func) {
return Optional.ofNullable(list)
.map(l -> l.stream().mapToDouble(func).sum())
.orElse(0.00);
}
/**
* integer求和
*
* @param list
* @param func
* @param <T>
* @return
*/
public static <T> Integer integerSum(List<T> list, ToIntFunction<T> func) {
return Optional.ofNullable(list)
.map(l -> l.stream().mapToInt(func).sum())
.orElse(0);
}
/**
* list总条数
*
* @param list
* @param pred
* @param <T>
* @return
*/
public static <T> Long count(List<T> list, Predicate<T> pred) {
return Optional.ofNullable(list)
.map(l -> l.stream().filter(pred).count())
.orElse(0L);
}
/**
* 通过条件过滤list
*
* @param list
* @param pred
* @param <T>
* @return
*/
public static <T> List<T> filter(List<T> list, Predicate<T> pred) {
return Optional.ofNullable(list)
.map(l -> l.stream().filter(pred).collect(Collectors.toList()))
.orElse(new ArrayList<>());
}
/**
* 通过条件分组
*
* @param list
* @param func
* @param <T>
* @return
*/
public static <T> List<T> sorted(List<T> list, Comparator<T> func) {
return Optional.ofNullable(list)
.map(l -> l.stream().sorted(func).collect(Collectors.toList()))
.orElse(new ArrayList<>());
}
}