集合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>
     * @param <R>
     * @return
     */
    public static <K, T, R> Map<K, List<R>> mapValueListEleConvert(Map<K, List<T>> srcMap, Class<R> tarEleClass) {
        if (isEmpty(srcMap)) {
            return getEmptyMap();
        }

        // 将列表内元素类型转换
        Map<K, List<R>> retMap = new HashMap<>(srcMap.size());
        srcMap.entrySet().forEach(entry -> {
            retMap.put(entry.getKey(), listMap2List(entry.getValue(), tag -> BeanConvertorUtil.convert(tag, tarEleClass)));
        });
        return retMap;
    }

    /**
     * List分组
     * @param srcList 原始list
     * @param keyMapper 映射器：将List元素映射成Map的key
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> Map<R, List<T>> listGroupingBy(List<T> srcList, Function<? super T, ? extends R> keyMapper) {
        if (isEmpty(srcList)) {
            return getEmptyMap();
        }

        return srcList.stream().collect(Collectors.groupingBy(keyMapper));
    }

    /**
     * List分组
     * @param srcList 原始list
     * @param keyMapper key映射器：将List元素映射成Map的key
     * @param valueMapper value映射器：将List元素映射成Map的value
     * @param <S>
     * @param <K>
     * @param <V>
     * @return
     */
    public static <S, K, V> Map<K, List<V>> listGroupingBy(List<S> srcList, Function<? super S, ? extends K> keyMapper, Function<? super S, ? extends V> valueMapper) {
        if (isEmpty(srcList)) {
            return getEmptyMap();
        }

        Map<? extends K, List<S>> baseMap = listGroupingBy(srcList, keyMapper);

        Map<K, List<V>> retMap = new HashMap<>(16);
        Iterator<? extends Map.Entry<? extends K, List<S>>> iter = baseMap.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry<? extends K, List<S>> map = iter.next();
            retMap.put(map.getKey(), listMap2List(map.getValue(), valueMapper));
        }

        return retMap;
    }

    /**
     * List转Map
     * @param srcList 原始List
     * @param mapper 映射器：将List元素映射成Map的key
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> Map<R, T> list2Map(List<T> srcList, Function<? super T, ? extends R> mapper) {
        if (isEmpty(srcList)) {
            return getEmptyMap();
        }

        return srcList.stream().collect(Collectors.toMap(mapper, v -> v));
    }

    /**
     * List转Map，保持原始顺序
     * @param srcList 原始List
     * @param mapper 映射器：将List元素映射成Map的key
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> Map<R, T> list2MapKeepOrder(List<T> srcList, Function<? super T, ? extends R> mapper) {
        if (isEmpty(srcList)) {
            return getEmptyMap();
        }

        // 获取key
        List<? extends R> keys = listMap2List(srcList, mapper);
        Map<R, T> retMap = new LinkedHashMap<>(srcList.size());

        Map<? extends R, T> tmpMap = list2Map(srcList, mapper);
        keys.forEach(k -> retMap.put(k, tmpMap.get(k)));

        return retMap;
    }

    /**
     * List转Map<br/>
     * 【注意】：value不能有null，否则转换失败
     * @param srcList 原始List
     * @param keyMapper List元素转Map的key
     * @param valueMapper List元素转Map的value
     * @param <S>
     * @param <K>
     * @param <V>
     * @return
     */
    public static <S, K, V> Map<K, V> list2Map(List<S> srcList, Function<? super S, ? extends K> keyMapper, Function<? super S, ? extends V> valueMapper) {
        if (isEmpty(srcList)) {
            return getEmptyMap();
        }

        return srcList.stream().collect(Collectors.toMap(keyMapper, valueMapper));
    }

    /**
     * List元素去重
     * @param srcList 原始列表
     * @param eleMapper 元素转换器
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> listDistinct(List<T> srcList, Function<? super T, ? extends R> eleMapper) {
        if (isEmpty(srcList)) {
            return getEmptyList();
        }

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

    /**
     * List元素去重
     * @param srcList 原始列表
     * @param <T>
     * @return
     */
    public static <T> List<T> listDistinct(List<T> srcList) {
        if (isEmpty(srcList)) {
            return getEmptyList();
        }

        return srcList.stream().distinct().collect(Collectors.toList());
    }

    /**
     * list取最小值
     * @param srcList
     * @param eleMapper
     * @param defaultValue
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R extends Comparable<R>> R listMin(List<T> srcList, Function<? super T, ? extends R> eleMapper, R defaultValue) {
        if (isEmpty(srcList)) {
            return defaultValue;
        }

        List<? extends R> newList = listMap2List(srcList, eleMapper);
        Collections.sort(newList);

        return newList.get(0);
    }

    /**
     * Set转List
     * @param srcSet
     * @param mapper
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> set2List(Set<T> srcSet, Function<T, R> mapper) {
        if (isEmpty(srcSet)) {
            return getEmptyList();
        }

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

    /**
     * Set转List，并去重
     * @param srcSet
     * @param mapper
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> set2ListAndDistinct(Set<T> srcSet, Function<T, R> mapper) {
        return set2List(srcSet, mapper).stream().distinct().collect(Collectors.toList());
    }

    /**
     * Map转List
     * @param map
     * @param mapper
     * @param <K>
     * @param <V>
     * @param <T>
     * @return
     */
    public static <K, V, T> List<T> map2List(Map<K, V> map, BiFunction<K, V, T> mapper) {
        if (isEmpty(map)) {
            return getEmptyList();
        }

        List<T> retList = new LinkedList<>();
        SimpleCollectionUtils.mapLoop(map, (k, v) -> retList.add(mapper.apply(k, v)));
        return retList;
    }

    /**
     * 将Map的key Set集合转为List
     * @param srcMap
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> List<K> mapKeyEle2List(Map<K, V> srcMap) {
        if (isEmpty(srcMap)) {
            return getEmptyList();
        }

        return new ArrayList<>(srcMap.keySet());
    }

    /**
     * 合并Map的List值
     * @param srcMap
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> List<V> mapValue2List(Map<K, List<V>> srcMap) {
        if (isEmpty(srcMap)) {
            return getEmptyList();
        }

        List<V> retList = new LinkedList<>();
        srcMap.values().forEach(retList::addAll);

        return retList;
    }

    /**
     * 合并Map的值到List
     * @param srcMap
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> List<V> mapValueEle2List(Map<K, V> srcMap) {
        if (isEmpty(srcMap)) {
            return getEmptyList();
        }

        return Lists.newArrayList(srcMap.values());
    }

    /**
     * 合并Map的List值
     * @param srcMap
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V, T> List<T> mapValue2List(Map<K, List<V>> srcMap, Class<T> tarEleClass) {
        if (isEmpty(srcMap)) {
            return getEmptyList();
        }

        List<T> retList = new LinkedList<>();
        srcMap.values().forEach(vs -> {
            retList.addAll(BeanConvertorUtil.convert(vs, tarEleClass));
        });

        return retList;
    }

    /**
     * Map中List值的元素类型转换
     * @param srcMap 原始map
     * @param tarEleClass 元素转换后类型
     * @param <K>
     * @param <V>
     * @param <T>
     * @return
     */
    public static <K, V, T> Map<K, List<T>> mapValueTypeConvert(Map<K, List<V>> srcMap, Class<T> tarEleClass) {
        if (isEmpty(srcMap)) {
            return getEmptyMap();
        }

        HashMap<K, List<T>> retMap = new HashMap<>(srcMap.size());
        Iterator<Map.Entry<K, List<V>>> iterator = srcMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<K, List<V>> kv = iterator.next();
            // value元素类型转换
            retMap.put(kv.getKey(), BeanConvertorUtil.convert(kv.getValue(), tarEleClass));
        }

        return retMap;
    }

    /**
     * Map中List值的元素类型转换
     * @param srcMap 原始map
     * @param valueEleMapper 元素映射关系
     * @param <K>
     * @param <V>
     * @param <T>
     * @return
     */
    public static <K, V, T> Map<K, List<T>> mapValueTypeConvert(Map<K, List<V>> srcMap, Function<? super V, ? extends T> valueEleMapper) {
        if (isEmpty(srcMap)) {
            return getEmptyMap();
        }

        Map<K, List<T>> retMap = new HashMap<>(srcMap.size());
        Iterator<Map.Entry<K, List<V>>> iterator = srcMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<K, List<V>> kv = iterator.next();
            retMap.put(kv.getKey(), listMap2List(kv.getValue(), valueEleMapper));
        }

        return retMap;
    }

    /**
     * Map中值元素转换
     * @param srcMap 原始map
     * @param valueEleMapper 值转换器
     * @param <K>
     * @param <V>
     * @param <T>
     * @return
     */
    public static <K, V, T> Map<K, T> mapValueConvert(Map<K, V> srcMap, Function<? super V, ? extends T> valueEleMapper) {
        if (isEmpty(srcMap)) {
            return getEmptyMap();
        }

        Map<K, T> retMap = new HashMap<>(srcMap.size());
        Iterator<Map.Entry<K, V>> iterator = srcMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<K, V> kv = iterator.next();
            retMap.put(kv.getKey(), valueEleMapper.apply(kv.getValue()));
        }

        return retMap;
    }

    /**
     * 过滤满足条件的元素
     * @param srcList
     * @param filter
     * @param <T>
     * @return
     */
    public static <T> List<T> filter(List<T> srcList, Predicate<T> filter) {
        if (isEmpty(srcList)) {
            return getEmptyList();
        }

        return srcList.stream().filter(filter).collect(Collectors.toList());
    }

    /**
     * 过滤满足条件的元素
     * @param srcSet
     * @param filter
     * @param <T>
     * @return
     */
    public static <T> Set<T> filter(Set<T> srcSet, Predicate<T> filter) {
        if (isEmpty(srcSet)) {
            return getEmptySet();
        }

        return srcSet.stream().filter(filter).collect(Collectors.toSet());
    }

    /**
     * 过滤满足条件的元素，并返回List
     * @param srcSet
     * @param filter
     * @param <T>
     * @return
     */
    public static <T> List<T> filterAnd2List(Set<T> srcSet, Predicate<T> filter) {
        return new ArrayList<>(filter(srcSet, filter));
    }

    /**
     * 过滤 key 满足条件的 元素
     * @param srcMap 原始map
     * @param filter 根据key过滤条件
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K,V> Map<K, V> filter(Map<K, V> srcMap, Predicate<K> filter) {
        if (isEmpty(srcMap)) {
            return getEmptyMap();
        }

        Map<K, V> retMap = new HashMap<>(16);

        SimpleCollectionUtils.mapLoop(srcMap, (k, v) -> {
            if (filter.test(k)) {
                retMap.put(k, v);
            }
        });

        return retMap;
    }

    /**
     * 过滤 value 满足条件的 元素
     * @param srcMap
     * @param filter
     * @param <K>
     * @param <V>
     * @return
     */
    public static <K, V> Map<K, V> filterByValue(Map<K, V> srcMap, Predicate<V> filter) {
        if (isEmpty(srcMap)) {
            return getEmptyMap();
        }

        Map<K, V> retMap = SimpleCollectionUtils.getEmptyMap();
        SimpleCollectionUtils.mapLoop(srcMap, (k, v) -> {
            if (filter.test(v)) {
                retMap.put(k, v);
            }
        });

        return retMap;
    }

    /**
     * 过滤并获取符合条件的元素个数
     * @param srcList 元素列表
     * @param filter 过滤器
     * @param <T>
     * @return
     */
    public static <T> int filterAndCount(List<T> srcList, Predicate<T> filter) {
        return filter(srcList, filter).size();
    }

    /**
     * 过滤并获取符合条件的元素个数
     * @param srcSet 元素列表
     * @param filter 过滤器
     * @param <T>
     * @return
     */
    public static <T> int filterAndCount(Set<T> srcSet, Predicate<T> filter) {
        return filter(srcSet, filter).size();
    }

    /**
     * 过滤并去重
     * @param srcList
     * @param filter
     * @param eleMapper4Distinct
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<R> filterAndDistinct(List<T> srcList, Predicate<T> filter, Function<? super T, ? extends R> eleMapper4Distinct) {
        return listDistinct(filter(srcList, filter), eleMapper4Distinct);
    }

    /**
     * 过滤并去重，然后计算元素个数
     * @param srcList
     * @param filter
     * @param eleMapper4Distinct
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> int filterAndDistinctCount(List<T> srcList, Predicate<T> filter, Function<? super T, ? extends R> eleMapper4Distinct) {
        return filterAndDistinct(srcList, filter, eleMapper4Distinct).size();
    }

    /**
     * 求和
     * @param srcList
     * @param valueMapper
     * @param <T>
     * @return
     */
    public static <T> Integer sum(List<T> srcList, Function<T, Integer> valueMapper) {
        if (isEmpty(srcList)) {
            return Consts.INTEGER_ZERO;
        }

        return srcList.stream().mapToInt(item -> valueMapper.apply(item)).sum();
    }

    /**
     * 取最大值
     * @param srcList
     * @param comparator
     * @param <T>
     * @return
     */
    public static <T> T max(List<T> srcList, Comparator<T> comparator) {
        if (isEmpty(srcList)) {
            return null;
        }

        Optional<T> result = srcList.stream().max(comparator);
        return result.isPresent() ? result.get() : null;
    }

    /**
     * 获取 集合的并集
     * @param list1
     * @param list2
     * @param <T>
     * @return
     */
    public static <T> List<T> union(List<T> list1, List<T> list2) {
        Set<T> set = listMap2Set(list1, v -> v);
        set.addAll(list2);

        return new ArrayList<>(set);
    }

    /**
     * 移除指定元素
     * @param baseList 基准列表
     * @param list2Remove 用于删除的元素
     * @param <T>
     * @return
     */
    public static <T> List<T> remove(List<T> baseList, List<T> list2Remove) {
        return filter(baseList, v -> !list2Remove.contains(v));
    }
}

• 依赖：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>23.0</version>
</dependency>
<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.2</version>
</dependency>

• BeanConvertorUtil：Bean操作工具类

package com.sqlu.tools.common

import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.util.Assert;

import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * @author stonelu
 * @date 2019-05-19 21:54
 */
public class BeanConvertorUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(BeanConvertorUtil.class);

    /**
     * 深拷贝 对象
     * @param sourceObj 原始对象
     * @param sourceObjClass 原始对象类型
     * @param <T>
     * @return
     */
    public static <T> T deepCopy(T sourceObj, Class<T> sourceObjClass) {
        if (Objects.isNull(sourceObj)) {
            return null;
        }

        try {
            return JSON.parseObject(JSON.toJSONString(sourceObj), sourceObjClass);
        } catch (Exception e) {
            LOGGER.error("深拷贝对象失败，原始对象为：" + JSON.toJSONString(sourceObj), e);
            throw new RuntimeException("深拷贝对象失败");
        }
    }

    /**
     * Bean转换
     * @param sourceObj 源Bean对象
     * @param targetClass 转换后对象类
     * @return
     */
    public static <S, T> T convert(S sourceObj, Class<T> targetClass) {
        if (sourceObj == null) {
            return null;
        }

        T instance = BeanUtils.instantiate(targetClass);
        // 允许出现这样的bean关系：
        // S和T 存在名字相同 且 数据类型不同 的字段
        // 效果：不会抛异常，在赋值操作时因为类型不能互转故自动忽略，即：该字段值为null
        BeanUtils.copyProperties(sourceObj, instance);
        return instance;
    }

    /**
     * 复制属性
     * @param sourceObj
     * @param destObj
     * @param <S>
     */
    public static <S> void copyProperties(S sourceObj, S destObj) {
        Assert.notNull(sourceObj, "原始对象不允许为空");
        Assert.notNull(destObj, "复制对象不允许为空");

        BeanUtils.copyProperties(sourceObj, destObj);
    }

    /**
     * Bean列表转换
     * @param sourceList 源Bean对象列表
     * @param targetItemClass 转换后列表元素类型
     * @return
     */
    public static <S, T> List<T> convert(List<S> sourceList, Class<T> targetItemClass) {
        if (sourceList == null) {
            return null;
        }
        if (sourceList.size() < 1) {
            return Lists.newArrayList();
        }

        return sourceList.stream().map(s -> convert(s, targetItemClass)).collect(Collectors.toList());
    }
}

• 依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.38</version>
</dependency>
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>23.0</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.3.5.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>4.3.5.RELEASE</version>
</dependency>