操作集合工具类

今天有时间写了一点集合工具类：

import org.apache.commons.beanutils.BeanPropertyValueEqualsPredicate;
import org.apache.commons.beanutils.BeanToPropertyValueTransformer;
import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.AllPredicate;

import java.util.*;

/**
 * 集合类的工具类
 */
public final class CollectionUtils {

    /**
     * 私有构造函数,防止误用
     */
    private CollectionUtils() {
    }

    /**
     * 判断集合是否为空
     *
     * @param collection 集合类型的对象
     * @param <T>        类型参数
     * @return 如果集合对象为空或者集合的size为0就返回true, 否则返回false
     */
    public static <T> boolean isNullOrEmpty(Collection<T> collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * 判断是否为一个非空的数组
     *
     * @param array 传入的数组
     * @param <T>   数组的类型参数
     * @return 如果数组为null或者数组的长度为0就返回true, 否则返回false
     */
    public static <T> boolean isNotNullOrEmptyArray(T[] array) {
        return !(array == null || array.length == 0);
    }

    /**
     * 合并所有集合
     *
     * @param lists List类型的集合
     * @param <T>   集合的参数类型
     * @return 合并后的集合
     */
    public static <T> List<T> mergeAll(List<T>... lists) {
        List<T> mergedList = new ArrayList<T>();
        for (int i = 0, len = lists.length; i < len; i++) {
            List<T> list = lists[i];
            if (list != null && !list.isEmpty()) {
                for (int j = 0, lenj = list.size(); j < lenj; j++) {
                    T obj = list.get(j);
                    if (obj != null) {
                        mergedList.add(obj);
                    }
                }
            }
        }
        return mergedList;
    }

    /**
     * 用数组创建一个ArrayList
     *
     * @param objs 元素
     * @param <T>  元素的类型
     * @return ArrayList
     */
    public static <T> List<T> asList(T... objs) {
        if (objs == null) {
            return Collections.EMPTY_LIST;
        }
        List<T> list = new ArrayList<T>();
        Collections.addAll(list, objs);
        return list;
    }

    /**
     * 创建简单Map的快捷方法
     *
     * @param key   键
     * @param value 值
     * @param <K>   键的类型
     * @param <V>   值的类型
     * @return Map
     */
    public static <K, V> Map<K, V> makeMap(K key, V value) {
        Map<K, V> map = new HashMap<K, V>();
        map.put(key, value);
        return map;
    }

    /**
     * 创建简单Map的快捷方法
     *
     * @param key1   键1
     * @param value1 值1
     * @param key2   键2
     * @param value2 值2
     * @param <K>    键的类型
     * @param <V>    值的类型
     * @return Map
     */
    public static <K, V> Map<K, V> makeMap(K key1, V value1, K key2, V value2) {
        Map<K, V> map = new HashMap<K, V>();
        map.put(key1, value1);
        map.put(key2, value2);
        return map;
    }

    /**
     * 数组包含
     *
     * @param array 数组
     * @param val   被包含值
     * @param <T>   类型
     * @return 是否包含
     */
    public static <T> boolean contains(T[] array, T val) {
        for (T t : array) {
            if (val.equals(t)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 用分隔符将字符串数组连接起来，构成一个字符串
     *
     * @param words     字符串数组
     * @param seperator 分隔符
     * @return 返回用分隔符连起来的字符串
     */
    public static String join(Object[] words, String seperator) {
        StringBuilder sb = new StringBuilder();
        if (words != null) {
            for (int i = 0; i < words.length; i++) {
                sb.append(words[i]);
                if (i < words.length - 1) {
                    sb.append(seperator);
                }
            }
        }
        return sb.toString();
    }

    /**
     * 将集合中的元素用分隔符连起来，构成一个字符串
     *
     * @param collection 集合
     * @param seperator  分隔符
     * @return 返回用分隔符连起来的字符串
     */
    public static String join(Collection<?> collection, String seperator) {
        Object[] objs = new Object[collection.size()];
        collection.toArray(objs);
        return join(objs, seperator);
    }

    /**
     * 根据集合中对象属性值查找元素
     *
     * @param collection    给定的集合
     * @param propertyName  集合中的元素的属性名
     * @param propertyValue 集合中元素属性名对应的属性值
     * @param <T>           集合的类型参数
     * @return 返回匹配的第一个元素
     */
    @SuppressWarnings("unchecked")
    public static <T> T find(Collection<T> collection, String propertyName, Object propertyValue) {
        return (T) org.apache.commons.collections.CollectionUtils.find(collection, new BeanPropertyValueEqualsPredicate(propertyName, propertyValue));
    }

    /**
     * 根据集合中对象属性值查找（多个属性值）
     *
     * @param collection       给定的集合
     * @param propertyValueMap 属性名称-值 map
     * @param <T>              集合的类型参数
     * @return 匹配的第一个元素
     */
    @SuppressWarnings("unchecked")
    public static <T> T find(Collection<T> collection, Map<String, Object> propertyValueMap) {
        Predicate[] predicates = new BeanPropertyValueEqualsPredicate[propertyValueMap.size()];
        Set<String> propertyNameSet = propertyValueMap.keySet();
        int index = 0;
        for (String propertyName : propertyNameSet) {
            predicates[index] = new BeanPropertyValueEqualsPredicate(propertyName, propertyValueMap.get(propertyName));
            index++;
        }
        Predicate allPredicate = new AllPredicate(predicates);
        return (T) org.apache.commons.collections.CollectionUtils.find(collection, allPredicate);
    }

    /**
     * 返回由指定属性名字的值构成的ArrayList集合 在集合中取每一个对象，将对象指定属性名的值拿出来，重新构成一个ArrayList
     *
     * @param collection   给定的集合
     * @param propertyName 集合中元素的某一个属性名
     * @param <T>          给定集合的类型参数
     * @param <PropType>   属性的类型
     * @return 返回新的集合ArrayList
     */
    public static <T, PropType> Collection<PropType> collect(Collection<T> collection, String propertyName) {
        Transformer transformer = new BeanToPropertyValueTransformer(propertyName);
        return org.apache.commons.collections.CollectionUtils.collect(collection, transformer);
    }

    /**
     * 复制一个数组
     *
     * @param sourceArray 要复制的目标数组
     * @param <T>         要复制的数组泛型类型
     * @return 新的数组
     */
    public static <T> T[] copy(T[] sourceArray) {
        if (sourceArray == null) {
            return null;
        }
        return Arrays.copyOf(sourceArray, sourceArray.length);
    }

}

/**
     * Map<String, String>转字符串.
     *
     * @param map Map<String, String>对象
     * @return json字符串
     */
    public static String convertMapToJSONString(Map<String, String> map) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("{");
        for (String key : map.keySet()) {
            stringBuilder.append("\"");
            stringBuilder.append(key);
            stringBuilder.append("\"");
            stringBuilder.append(":");
            stringBuilder.append("\"");
            stringBuilder.append(map.get(key));
            stringBuilder.append("\"");
            stringBuilder.append(",");
        }
        String result = stringBuilder.toString();
        if (result.endsWith(",")) {
            result = result.substring(0, result.length() - 1);
        }
        return result + "}";
    }

这也是代码优化的第一步。