net.guerlab.spring.commons.util.CollectionUtil Maven / Gradle / Ivy

Go to download
package net.guerlab.spring.commons.util;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 集合工具类
 *
 * @author guer
 *
 */
public class CollectionUtil {

    private CollectionUtil() {
    }

    /**
     * 判断是否为空集合
     *
     * @param coll
     *            集合
     * @return 否为空集合
     */
    public static boolean isEmpty(
            Collection coll) {
        return coll == null || coll.isEmpty();
    }

    /**
     * 判断是否为非空集合
     *
     * @param coll
     *            集合
     * @return 否为非空集合
     */
    public static boolean isNotEmpty(
            Collection coll) {
        return !isEmpty(coll);
    }

    /**
     * 集合转换为Map结构
     *
     * @param 
     *            集合元素类型
     * @param 
     *            map结果集key类型
     * @param coll
     *            集合
     * @param keyMapper
     *            key映射关系
     * @return Map结构数据
     */
    public static  Map toMap(
            Collection coll,
            Function keyMapper) {
        return toMap(coll, keyMapper, e -> e);
    }

    /**
     * 集合转换为Map结构
     *
     * @param 
     *            集合元素类型
     * @param 
     *            map结果集key类型
     * @param 
     *            map结果集value类型
     * @param coll
     *            集合
     * @param keyMapper
     *            key映射关系
     * @param valueMapper
     *            value映射关系
     * @return Map结构数据
     */
    public static  Map toMap(
            Collection coll,
            Function keyMapper,
            Function valueMapper) {
        return toMap(coll, keyMapper, valueMapper, throwingMerger(), HashMap::new);
    }

    /**
     * 集合转换为Map结构
     *
     * @param 
     *            集合元素类型
     * @param 
     *            map结果集key类型
     * @param 
     *            map结果集value类型
     * @param 
     *            map结果集类型
     * @param coll
     *            集合
     * @param keyMapper
     *            key映射关系
     * @param valueMapper
     *            value映射关系
     * @param mergeFunction
     *            值合并方法
     * @param mapSupplier
     *            map构造方法
     * @return Map结构数据
     */
    public static > Map toMap(
            Collection coll,
            Function keyMapper,
            Function valueMapper,
            BinaryOperator mergeFunction,
            Supplier mapSupplier) {
        if (isEmpty(coll)) {
            return Collections.emptyMap();
        }

        return stream(coll).collect(Collectors.toMap(keyMapper, valueMapper,
                mergeFunction != null ? mergeFunction : throwingMerger(), mapSupplier));
    }

    private static  BinaryOperator throwingMerger() {
        return (
                u,
                v) -> {
            throw new IllegalStateException(String.format("Duplicate key %s", u));
        };
    }

    /**
     * 集合转变为list集合

     * 不转换的内容可在映射关系中返回null来过滤该值
     *
     * @param 
     *            输入集合元素类型
     * @param 
     *            输出list元素类型
     * @param coll
     *            集合
     * @param mapper
     *            映射关系
     * @return list集合
     */
    public static  List toList(
            Collection coll,
            Function mapper) {
        if (isEmpty(coll)) {
            return Collections.emptyList();
        }

        return stream(coll).map(mapper).filter(Objects::nonNull).collect(Collectors.toList());
    }

    /**
     * 集合转变为set集合

     * 不转换的内容可在映射关系中返回null来过滤该值
     *
     * @param 
     *            输入集合元素类型
     * @param 
     *            输出set元素类型
     * @param coll
     *            集合
     * @param mapper
     *            映射关系
     * @return set集合
     */
    public static  Set toSet(
            Collection coll,
            Function mapper) {
        if (isEmpty(coll)) {
            return Collections.emptySet();
        }

        return stream(coll).map(mapper).filter(Objects::nonNull).collect(Collectors.toSet());
    }

    /**
     * 将集合进行分组
     *
     * @param 
     *            输入集合元素类型
     * @param 
     *            分组key类型
     * @param coll
     *            集合
     * @param mapper
     *            分组关系
     * @return 分组后的集合map
     */
    public static  Map> group(
            Collection coll,
            Function mapper) {
        if (isEmpty(coll)) {
            return Collections.emptyMap();
        }

        return stream(coll).collect(Collectors.groupingBy(mapper));
    }

    private static  Stream stream(
            Collection coll) {
        return coll.stream().filter(Objects::nonNull);
    }
}