你是否对 JDK 8 Lambda 表达式感兴趣？你是否刚接触 Lambda 表达式？你是否正在工作中使用 Lambda 表达式？如果是，请阅读完本篇文章，我将通过书写一个工具类去简化 Lambda 写法，加快开发效率。
这里我举几个例子，来看看我们使用工具类前后的对比：
1、筛选集合数据
- 初始化数据
// [1,2,3]
List<Integer> nums = new ArrayList<Integer>(){{
add(1);
add(2);
add(3);
}};
- 以前写法
List<Integer> nums = nums.stream().filter(e -> e > 0).collect(Collectors.toList());
- 现在写法
List<Integer> nums = Lambdas.filterList(nums, e -> e > 0);
也许看到这，你会说才简写了这么点，还封装个工具类，多麻烦啊。别急，请继续看下去。
2、将 Collection 转换为 Map
- 初始化数据
// 用户
public class User {
private String id;
private String name;
// getter setter 省略
public User(String id, String name, Integer age) {
this.id = id;
this.name = name;
this.age = age;
}
}
// 数据初始化
List<User> users = new ArrayList<User>(){{
add(new User("1", "张三", 10));
add(new User("2", "李四", 10));
add(new User("3", "王五", 11));
}};
- 以前写法
// 转 Map<K,V>
Map<String, User> userIdMap = users.stream().collect(Collectors.toMap(User::getId, Function.identity()));
// 转 Map<K, List<V>>
Map<Integer, List<String>> userAgeNameListMap = users.stream().collect(Collectors.groupingBy(User::getAge, Collectors.mapping(User::getName, Collectors.toList())));
- 现在写法
// 转 Map<K,V>
Map<String, User> userIdMap = Lambdas.convertMap(users, User::getId);
// 转 Map<K, List<V>>
Map<String, List<String>> userAgeNameListMap = Lambdas.convertMultiMap(users, User::getId, User::getName);
是否变得简洁多了~
3、集合|数组通过某个字符连接为字符串
- 以前写法
String names = users.stream().map(User::getName).collect(Collectors.joining(","));
- 现在写法
String names = Lambdas.joining(users, User::getName, ",");
还有一些简洁的写法，在这里我就不一一举例了，感兴趣的小伙伴可以将工具类拷贝到自己的项目里，练习练习。
由于作者学识有限，工具类中如有不足之处或有需要改进和优化的地方，不吝赐教。
4、Lambdas 工具类
/**
* <h2>集合工具类</h2>
*
* @author Cpz
* @since 2023-04-15
*/
public final class Lambdas {
/**
* 空字符串
*/
public static final String EMPTY = "";
/**
* 过滤集合中的元素
*
* @param collection 原始集合
* @param predicate 过滤条件
* @param <T> 集合中的元素类型
* @return 过滤后的集合
*/
public static <T> List<T> filterList(Collection<T> collection, Predicate<T> predicate) {
if (null == collection || collection.isEmpty()) {
return new ArrayList<>();
}
return collection.stream().filter(predicate).collect(Collectors.toList());
}
/**
* Collection 转 List 含去重，key 相同时，选择旧
*
* @param collection
* @param keyMapper
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<T> distinct(Collection<T> collection, Function<T, R> keyMapper) {
if (null == collection || collection.isEmpty()) {
return new ArrayList<>();
}
return distinct(collection, keyMapper, (t1, t2) -> t1);
}
/**
* Collection 转 List 含去重，key 相同时，通过 cover 进行旧|新选择
*
* @param from
* @param keyMapper
* @param cover
* @param <T>
* @param <R>
* @return
*/
public static <T, R> List<T> distinct(Collection<T> from, Function<T, R> keyMapper, BinaryOperator<T> cover) {
if (from == null || from.isEmpty()) {
return new ArrayList<>();
}
return new ArrayList<>(convertMap(from, keyMapper, Function.identity(), cover).values());
}
/**
* Collection 转 List，
*
* @param from 集合
* @param func 转换为某个属性，非空
* @param filter 进一步筛选元素
* @param <T>
* @param <U>
* @return
*/
public static <T, U> List<U> convertList(Collection<T> from, Function<T, U> func, Predicate<T> filter) {
if (from == null || from.isEmpty()) {
return new ArrayList<>();
}
return from.stream().filter(filter).map(func).filter(Objects::nonNull).collect(Collectors.toList());
}
/**
* Collection 转 List
*
* @param from 集合
* @param func 转换为某个属性，非空
* @param <T>
* @param <U>
* @return
*/
public static <T, U> List<U> convertList(Collection<T> from, Function<T, U> func) {
if (from == null || from.isEmpty()) {
return new ArrayList<>();
}
return from.stream().map(func).filter(Objects::nonNull).collect(Collectors.toList());
}
/**
* Collection 转 Set
*
* @param from 集合
* @param func 转换为某个属性，非空
* @param <T>
* @param <U>
* @return
*/
public static <T, U> Set<U> convertSet(Collection<T> from, Function<T, U> func) {
if (from == null || from.isEmpty()) {
return new HashSet<>();
}
return from.stream().map(func).filter(Objects::nonNull).collect(Collectors.toSet());
}
public static <T, K> Map<K, T> convertMap(Collection<T> from, Function<T, K> keyFunc) {
if (from == null || from.isEmpty()) {
return new HashMap<>();
}
return convertMap(from, keyFunc, Function.identity());
}
public static <T, K> Map<K, T> convertMap(Collection<T> from, Function<T, K> keyFunc, Supplier<? extends Map<K, T>> supplier) {
if (from == null || from.isEmpty()) {
return supplier.get();
}
return convertMap(from, keyFunc, Function.identity(), supplier);
}
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
if (from == null || from.isEmpty()) {
return new HashMap<>();
}
return convertMap(from, keyFunc, valueFunc, (v1, v2) -> v1);
}
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc, BinaryOperator<V> mergeFunction) {
if (from == null || from.isEmpty()) {
return new HashMap<>();
}
return convertMap(from, keyFunc, valueFunc, mergeFunction, HashMap::new);
}
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc, Supplier<? extends Map<K, V>> supplier) {
if (from == null || from.isEmpty()) {
return supplier.get();
}
return convertMap(from, keyFunc, valueFunc, (v1, v2) -> v1, supplier);
}
/**
* Collection 转换为 Map
*
* @param from 集合
* @param keyFunc key 转换为 某个属性
* @param valueFunc value 转换为 某个属性
* @param mergeFunction key 相同时，选择旧还是新 (旧，新) -> 旧|新
* @param supplier 转换为什么类型 Map<K,V> eg: HashMap::new
* @param <T> 集合元素类型
* @param <K> 键类型
* @param <V> 值类型
* @return Map<K, V>
*/
public static <T, K, V> Map<K, V> convertMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc, BinaryOperator<V> mergeFunction, Supplier<? extends Map<K, V>> supplier) {
if (from == null || from.isEmpty()) {
return new HashMap<>();
}
return from.stream().collect(Collectors.toMap(keyFunc, valueFunc, mergeFunction, supplier));
}
/***
* Collection 实现分组操作，List
* @param from
* @param keyFunc
* @return
* @param <T>
* @param <K>
*/
public static <T, K> Map<K, List<T>> convertMultiMap(Collection<T> from, Function<T, K> keyFunc) {
if (from == null || from.isEmpty()) {
return new HashMap<>();
}
return convertMultiMap(from, keyFunc, Function.identity());
}
/**
* Collection 实现分组操作，List value 为 对象中的某个属性
*
* @param from
* @param keyFunc
* @param valueFunc
* @param <T>
* @param <K>
* @param <V>
* @return
*/
public static <T, K, V> Map<K, List<V>> convertMultiMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
if (from == null || from.isEmpty()) {
return new HashMap<>();
}
return from.stream().collect(Collectors.groupingBy(keyFunc, Collectors.mapping(valueFunc, Collectors.toList())));
}
/**
* Collection 实现分组操作，Set
*
* @param from
* @param keyFunc
* @param valueFunc
* @param <T>
* @param <K>
* @param <V>
* @return
*/
public static <T, K, V> Map<K, Set<V>> convertMultiSetMap(Collection<T> from, Function<T, K> keyFunc, Function<T, V> valueFunc) {
if (from == null || from.isEmpty()) {
return new HashMap<>();
}
return from.stream().collect(Collectors.groupingBy(keyFunc, Collectors.mapping(valueFunc, Collectors.toSet())));
}
/**
* 获取 List 中的第一个元素
*
* @param from
* @param <T>
* @return
*/
public static <T> T getFirst(List<T> from) {
return from == null || from.isEmpty() ? null : from.get(0);
}
/**
* 经过筛选后获取 List 中的第一个元素
*
* @param from
* @param predicate
* @param <T>
* @return
*/
public static <T> T findFirst(List<T> from, Predicate<T> predicate) {
if (from == null || from.isEmpty()) {
return null;
}
return from.stream().filter(predicate).findFirst().orElse(null);
}
/**
* 经过筛选后获取 List 中的第一个元素，没有则设置默认值
*
* @param from
* @param predicate
* @param func
* @param defaultValue
* @param <T>
* @param <U>
* @return
*/
public static <T, U> U findFirst(List<T> from, Predicate<T> predicate, Function<T, U> func, U defaultValue) {
if (from == null || from.isEmpty()) {
return defaultValue;
}
return from.stream().filter(predicate).map(func).findFirst().orElse(defaultValue);
}
/**
* 向集合元素中添加多个非空元素
*
* @param collection
* @param items
* @param <T>
* @return
*/
public static <T> Collection<T> addNonnull(Collection<T> collection, T... items) {
for (T item : items) {
if (item != null) {
collection.add(item);
}
}
return collection;
}
/**
* 集合是否存在匹配的元素
*
* @param collection
* @param predicate
* @param <T>
* @return
*/
public static <T> boolean anyMatch(Collection<T> collection, Predicate<T> predicate) {
if (null == collection || collection.isEmpty()) {
return false;
}
return collection.stream().anyMatch(predicate);
}
/**
* 集合所有元素是否都匹配
*
* @param collection
* @param predicate
* @param <T>
* @return
*/
public static <T> boolean allMatch(Collection<T> collection, Predicate<T> predicate) {
if (null == collection || collection.isEmpty()) {
return false;
}
return collection.stream().allMatch(predicate);
}
/**
* 将字符串通过分页字符分割成数组，然后进行字符串转换为需要判断的元素类型，最后判断元素是否在数组中
*
* @param str
* @param delimiter
* @param func
* @param ele
* @param <T>
* @return
*/
public static <T> boolean anyMatch(String str, CharSequence delimiter, Function<String, T> func, T ele) {
if (null == str || str.length() == 0) {
return false;
}
return Arrays.stream(str.split(delimiter.toString())).map(func).collect(Collectors.toList()).contains(ele);
}
/**
* 将字符串通过分页字符分割成数组，然后判断元素是否在数组中
*
* @param str
* @param delimiter
* @param ele
* @param <T>
* @return
*/
public static <T> boolean anyMatch(String str, CharSequence delimiter, T ele) {
if (null == str || str.length() == 0) {
return false;
}
return Arrays.stream(str.split(delimiter.toString())).collect(Collectors.toList()).contains(ele);
}
/**
* 数组是否包含某个元素
*
* @param array
* @param element
* @param <T>
* @return
*/
public static <T> boolean contains(T[] array, T element) {
return Arrays.asList(array).contains(element);
}
/**
* 集合是否存在空元素
*
* @param collections
* @param <T>
* @return
*/
public static <T> boolean isAnyEmpty(Collection<T>... collections) {
return Arrays.stream(collections).anyMatch(ele -> (null == ele || ele.isEmpty()));
}
/**
* 集合中所有元素是否都为空
*
* @param collections
* @param <T>
* @return
*/
public static <T> boolean isAllEmpty(Collection<T>... collections) {
return Arrays.stream(collections).allMatch(ele -> null == ele || ele.isEmpty());
}
/**
* 将集合元素先转为String类型，然后通过某个字符去连接
*
* @param collection
* @param delimiter
* @param <T>
* @return
*/
public static <T> String joining(Collection<T> collection, CharSequence delimiter) {
if (null == collection || collection.isEmpty()) {
return EMPTY;
}
return collection.stream().map(String::valueOf).collect(Collectors.joining(delimiter));
}
/**
* 将集合元素中的某个属性先转为String类型，然后通过某个字符去连接
*
* @param collection
* @param func
* @param delimiter
* @param <T>
* @param <U>
* @return
*/
public static <T, U> String joining(Collection<T> collection, Function<T, U> func, CharSequence delimiter) {
if (null == collection || collection.isEmpty()) {
return EMPTY;
}
return collection.stream().map(func).map(String::valueOf).collect(Collectors.joining(delimiter));
}
/**
* 将数组元素先转为String类型，然后通过某个字符去连接
*
* @param array
* @param delimiter
* @param <T>
* @return
*/
public static <T> String joining(T[] array, CharSequence delimiter) {
if (null == array || array.length == 0) {
return EMPTY;
}
return Arrays.stream(array).map(String::valueOf).collect(Collectors.joining(delimiter));
}
/**
* 将数组元素中的某个属性先转为String类型，然后通过某个字符去连接
*
* @param array
* @param func
* @param delimiter
* @param <T>
* @param <U>
* @return
*/
public static <T, U> String joining(T[] array, Function<T, U> func, CharSequence delimiter) {
if (null == array || array.length == 0) {
return EMPTY;
}
return Arrays.stream(array).map(func).map(String::valueOf).collect(Collectors.joining(delimiter));
}
}
网友评论