java 常用集合工具类方法总结

公司的代码比较强调整洁和规范，一些集合的判断之前都是自己手写的，现在都使用java自身封装好的方法，现在不常用到的一些方法做下总结。

判断集合是否为空

CollectionUtils.isEmpty(list)

public static boolean isEmpty(Collection coll) {
    return coll == null || coll.isEmpty();
}

判断集合是否不为空

CollectionUtils.isNotEmpty(list)

public static boolean isNotEmpty(Collection coll) {
    return !CollectionUtils.isEmpty(coll);
}

两个集合取并集

CollectionUtils.union(listA, listB)

public static Collection union(final Collection a, final Collection b) {
    ArrayList list = new ArrayList();
    Map mapa = getCardinalityMap(a);
    Map mapb = getCardinalityMap(b);
    Set elts = new HashSet(a);
    elts.addAll(b);
    Iterator it = elts.iterator();
    while(it.hasNext()) {
        Object obj = it.next();
        for(int i=0,m=Math.max(getFreq(obj,mapa),getFreq(obj,mapb));i<m;i++) {
            list.add(obj);
        }
    }
    return list;
}

两个集合取交集

CollectionUtils.intersection(listA, listB)

public static Collection intersection(final Collection a, final Collection b) {
    ArrayList list = new ArrayList();
    Map mapa = getCardinalityMap(a);
    Map mapb = getCardinalityMap(b);
    Set elts = new HashSet(a);
    elts.addAll(b);
    Iterator it = elts.iterator();
    while(it.hasNext()) {
        Object obj = it.next();
        for(int i=0,m=Math.min(getFreq(obj,mapa),getFreq(obj,mapb));i<m;i++) {
            list.add(obj);
        }
    }
    return list;
}

两个集合取差集

CollectionUtils.subtract(listA, listB)

public static Collection subtract(final Collection a, final Collection b) {
    ArrayList list = new ArrayList( a );
    for (Iterator it = b.iterator(); it.hasNext();) {
        list.remove(it.next());
    }
    return list;
}

集的补集（析取）

CollectionUtils.disjunction(listA, listB)

public static Collection disjunction(final Collection a, final Collection b) {
    ArrayList list = new ArrayList();
    Map mapa = getCardinalityMap(a);
    Map mapb = getCardinalityMap(b);
    Set elts = new HashSet(a);
    elts.addAll(b);
    Iterator it = elts.iterator();
    while(it.hasNext()) {
        Object obj = it.next();
        for(int i=0,m=((Math.max(getFreq(obj,mapa),getFreq(obj,mapb)))-(Math.min(getFreq(obj,mapa),getFreq(obj,mapb))));i<m;i++) {
            list.add(obj);
        }
    }
    return list;
}

两个集合是否相等

CollectionUtils.isEqualCollection(listA,listB)

public static boolean isEqualCollection(final Collection a, final Collection b) {
    if(a.size() != b.size()) {
        return false;
    } else {
        Map mapa = getCardinalityMap(a);
        Map mapb = getCardinalityMap(b);
        if(mapa.size() != mapb.size()) {
            return false;
        } else {
            Iterator it = mapa.keySet().iterator();
            while(it.hasNext()) {
                Object obj = it.next();
                if(getFreq(obj,mapa) != getFreq(obj,mapb)) {
                    return false;
                }
            }
            return true;
        }
    }
}

当不为空时添加元素

CollectionUtils.addIgnoreNull(personList,o);

public static boolean addIgnoreNull(Collection collection, Object object) {
    return (object == null ? false : collection.add(object));
}

判断两个集合是否存在交集

CollectionUtils.containsAny(a,b)

public static boolean containsAny(final Collection coll1, final Collection coll2) {
    if (coll1.size() < coll2.size()) {
        for (Iterator it = coll1.iterator(); it.hasNext();) {
            if (coll2.contains(it.next())) {
                return true;
            }
        }
    } else {
        for (Iterator it = coll2.iterator(); it.hasNext();) {
            if (coll1.contains(it.next())) {
                return true;
            }
        }
    }
    return false;
}

是否是子集

CollectionUtils.isSubCollection(a,b)

public static boolean isSubCollection(final Collection a, final Collection b) {
    Map mapa = getCardinalityMap(a);
    Map mapb = getCardinalityMap(b);
    Iterator it = a.iterator();
    while (it.hasNext()) {
        Object obj = it.next();
        if (getFreq(obj, mapa) > getFreq(obj, mapb)) {
            return false;
        }
    }
    return true;
}

是否是真子集

CollectionUtils.isProperSubCollection(a,b)

public static boolean isProperSubCollection(final Collection a, final Collection b) {
    return (a.size() < b.size()) && CollectionUtils.isSubCollection(a,b);
}

对象在集合中出现的次数

CollectionUtils.cardinality(a,b)

public static int cardinality(Object obj, final Collection coll) {
    if (coll instanceof Set) {
        return (coll.contains(obj) ? 1 : 0);
    }
    if (coll instanceof Bag) {
        return ((Bag) coll).getCount(obj);
    }
    int count = 0;
    if (obj == null) {
        for (Iterator it = coll.iterator();it.hasNext();) {
            if (it.next() == null) {
                count++;
            }
        }
    } else {
        for (Iterator it = coll.iterator();it.hasNext();) {
            if (obj.equals(it.next())) {
                count++;
            }
        }
    }
    return count;
}

找到集合中第一个满足条件的元素

CollectionUtils.find(a,predicate)

public static Object find(Collection collection, Predicate predicate) {
    if (collection != null && predicate != null) {
        for (Iterator iter = collection.iterator(); iter.hasNext();) {
            Object item = iter.next();
            if (predicate.evaluate(item)) {
                return item;
            }
        }
    }
    return null;
}

对集合中每个元素执行指定的闭包

CollectionUtils.forAllDo(a,closure)

public static void forAllDo(Collection collection, Closure closure) {
    if (collection != null && closure != null) {
        for (Iterator it = collection.iterator(); it.hasNext();) {
            closure.execute(it.next());
        }
    }
}

过滤掉某些不满足指定条件的元素

CollectionUtils.filter(a,predicate)

public static void filter(Collection collection, Predicate predicate) {
    if (collection != null && predicate != null) {
        for (Iterator it = collection.iterator(); it.hasNext();) {
            if (predicate.evaluate(it.next()) == false) {
                it.remove();
            }
        }
    }
}

对集合中每个元素进行指定的操作，这个操作会影响传入的集合

CollectionUtils.transform(a,transformer)

public static void transform(Collection collection, Transformer transformer) {
    if (collection != null && transformer != null) {
        if (collection instanceof List) {
            List list = (List) collection;
            for (ListIterator it = list.listIterator(); it.hasNext();) {
                it.set(transformer.transform(it.next()));
            }
        } else {
            Collection resultCollection = collect(collection, transformer);
            collection.clear();
            collection.addAll(resultCollection);
        }
    }
}

返回满足指定条件的元素个数

CollectionUtils.countMatches(a,predicate)

public static int countMatches(Collection inputCollection, Predicate predicate) {
    int count = 0;
    if (inputCollection != null && predicate != null) {
        for (Iterator it = inputCollection.iterator(); it.hasNext();) {
            if (predicate.evaluate(it.next())) {
                count++;
            }
        }
    }
    return count;
}

判断集合中是否存在满足某个指定条件的元素

CollectionUtils.exists(a,predicate)

public static boolean exists(Collection collection, Predicate predicate) {
    if (collection != null && predicate != null) {
        for (Iterator it = collection.iterator(); it.hasNext();) {
            if (predicate.evaluate(it.next())) {
                return true;
            }
        }
    }
    return false;
}

找出集合中满足指定条件的所有元素

CollectionUtils.select(a,predicate)

public static Collection select(Collection inputCollection, Predicate predicate) {
    ArrayList answer = new ArrayList(inputCollection.size());
    select(inputCollection, predicate, answer);
    return answer;
}

找出集合中所有不满足条件的元素

CollectionUtils.selectRejected(a,predicate)

public static Collection selectRejected(Collection inputCollection, Predicate predicate) {
    ArrayList answer = new ArrayList(inputCollection.size());
    selectRejected(inputCollection, predicate, answer);
    return answer;
}

反转给定数组的顺序

CollectionUtils.reverseArray(Object[] array)

public static void reverseArray(Object[] array) {
    int i = 0;
    int j = array.length - 1;
    Object tmp;

    while (j > i) {
        tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
        j--;
        i++;
    }
}