集合Stream流操作工具类

前言

JDK1.8 发布的集合流(Stream)操作支持Lambda表达式，省去for、foreach等架子，有效提升编码效率。
但重复的拼装出相同的流操作表达式，又出现了原先for、foreach存在的架子问题，故而，本文将给出一些笔者日常工作中经常使用到的流操作工具方法，希望能减少不必要的重复代码，将宝贵的时间精力放在功能、产品、生活上。

代码

• 示例

@Data
@AllArgsConstructor
class Person {
   
   
	private Long id;
	private String name;
}

List<Person> personList = new LinkedList<>();
personList.add(new Person(1L, "张三"));
...

// 需求1：从personList提取出idList
// 使用工具前：
List<Long> personIdList = personList.stream().map(Person::getId).collect(Collectors.toList());
// 使用工具后：
List<Long> personIdList = StreamUtils.listMap2List(personList, Person::getId);


// 需求2：获取 Map<id, person>
// 使用工具前：
Map<Long, Person> idPersonMap = personList.stream().collect(Collectors.toMap(Person::getId, v->v));
// 使用工具后：
Map<Long, Person> idPersonMap = StreamUtils.list2Map(personList, Person::getId);


// 需求3：获取 Map<id, name>
// 使用工具前：
Map<Long, Person> idNameMap = personList.stream().collect(Collectors.toMap(Person::getId, Person::getName));
// 使用工具后：
StreamUtils.list2Map(personList, Person::getId, Person::getName);

// 需求3：filter
// 使用工具前：
List<Person> newPersonList = personList.stream().filter(p -> p.getId() > 5L).collect(Collectors.toList());
// 使用工具后：
List<Person> newPersonList = StreamUtils.filter(personList, p -> p.getId() > 5L);

• StreamUtils:

package com.sqlu.tools.common;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.MapUtils;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * @author stonelu
 * @date 2019-06-09 19:26
 */
public class StreamUtils {
   
   
	public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
   
   
        Map<Object, Boolean> map = new ConcurrentHashMap<>();
        return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }

    private static boolean isEmpty(Map map) {
   
   
        return MapUtils.isEmpty(map);
    }

    private static boolean isEmpty(Collection list) {
   
   
        return CollectionUtils.isEmpty(list);
    }

    private static <E> List<E> getEmptyList() {
   
   
        return Lists.newArrayList();
    }

    private static <E> Set<E> getEmptySet() {
   
   
        return Sets.newHashSet();
    }

    private static <K, V> Map<K, V> getEmptyMap() {
   
   
        return Maps.newHashMap();
    }

    /**
     * List通过Map映射成新List列表
     * @param srcList 原始List
     * @param mapper 元素映射器
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> listMap2List(List<T> srcList, Function<? super T, ? extends R> mapper) {
   
   
        if (isEmpty(srcList)) {
   
   
            return getEmptyList();
        }

        return srcList.stream().map(mapper).collect(Collectors.toList());
    }

    /**
     * List通过Map映射成新List列表
     * @param srcList 原始List
     * @param mapper 元素映射器
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> listMap2ListFilterNull(List<T> srcList, Function<? super T, ? extends R> mapper) {
   
   
        return filter(listMap2List(srcList, mapper), NullableUtilStatic::nonNull);
    }

    /**
     * 将list的所有元素(也是list)合并成一个list
     * @param srcList
     * @param mapper
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> listEleListMerge2List(List<T> srcList, Function<? super T, ? extends List<R>> mapper) {
   
   
        if (isEmpty(srcList)) {
   
   
            return getEmptyList();
        }

        List<? extends List<R>> tmpList = listMap2List(srcList, mapper);
        List<R> retList = new LinkedList<>();
        tmpList.forEach(retList::addAll);
        return retList;
    }

    /**
     * List通过Map映射成Set列表
     * @param srcList 原始list
     * @param mapper 元素映射器
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> Set<R> listMap2Set(List<T> srcList, Function<? super T, ? extends R> mapper) {
   
   
        if (isEmpty(srcList)) {
   
   
            return getEmptySet();
        }

        return srcList.stream().map(mapper).collect(Collectors.toSet());
    }

    /**
     * 适用于value为List的Map，将List元素类型进行转换
     * @param srcMap 原始map
     * @param tarEleClass list元素需映射为哪个类型
     * @param <K>
     * @param <T&g