org.chobit.commons.utils.Collections2 Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common-utils Show documentation
The newest version!
package org.chobit.commons.utils;


import org.chobit.commons.model.Pair;

import java.util.*;

import static org.chobit.commons.utils.StrKit.isBlank;

/**
 * 集合操作辅助类
 *
 * @author robin
 */
public final class Collections2 {

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

    /**
     * 判断Map是否不为空
     *
     * @param map 目标集合
     * @return Map是否不为空
     */
    public static boolean isNotEmpty(Map map) {
        return !isEmpty(map);
    }

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

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


    /**
     * 根据提供的元素创建列表
     *
     * @param elements 列表元素
     * @param       列表元素类型
     * @return 新建的列表
     */
    @SafeVarargs
    public static  List listOf(T... elements) {
        List list = new LinkedList<>();
        if (null == elements) {
            return list;
        }
        Collections.addAll(list, elements);
        return list;
    }


    /**
     * 取出集合中的第一个元素
     *
     * @param coll 集合
     * @param   集合元素类型
     * @return 集合中的第一个元素。如集合为空返回null
     */
    public static  T first(Collection coll) {
        if (isEmpty(coll)) {
            return null;
        }
        return coll.iterator().next();
    }


    /**
     * 将Pair集合转为Map对象
     *
     * @param pairs Pair集合
     * @param    Key 类型
     * @param    Value 类型
     * @return Map对象
     */
    public static  Map toMap(Collection> pairs) {
        Map map = new HashMap<>(8);
        for (Pair p : pairs) {
            map.put(p.getKey(), p.getValue());
        }
        return map;
    }


    /**
     * 将Map对象转为Pair集合
     *
     * @param map Map对象
     * @param  Key类型
     * @param  Value类型
     * @return Pair集合
     */
    public static  List> toPairs(Map map) {
        List> result = new LinkedList<>();
        for (Map.Entry entry : map.entrySet()) {
            result.add(new Pair<>(entry.getKey(), entry.getValue()));
        }
        return result;
    }


    /**
     * 将key和value放入一个map实例中
     *
     * @param key   key的值
     * @param value value的值
     * @param    Key类型
     * @param    Value类型
     * @return Map对象
     */
    public static  Map mapOf(K key, V value) {
        Map map = new HashMap<>(1);
        map.put(key, value);
        return map;
    }


    /**
     * 拼接集合数据为字符串
     *
     * @param coll      集合
     * @param separator 分隔符
     * @param        集合数据类型
     * @return 集合数据对应的字符串
     */
    public static  String join(Collection coll, String separator) {
        if (isEmpty(coll)) {
            return "";
        }
        StringBuilder builder = new StringBuilder();
        for (T t : coll) {
            if (null == t || isBlank(t.toString())) {
                continue;
            }
            if (builder.length() > 0) {
                builder.append(separator);
            }
            builder.append(t);
        }
        return builder.toString();
    }


    private Collections2() {
        throw new UnsupportedOperationException("Private constructor, cannot be accessed.");
    }
}