CollectionUtils和Collections的使用

  CollectionUtils是对Collection集合操作的类方法，这个类不是java自带的类方法，需要另外导入一个commons-collections.jar包才可以使用这个类中方法。因为这个CollectionUtils是对Collection集合操作的，所以我先简单介绍一下Collection。

Collection（单例集合  ） 
├-List（有序，可重复 ）  
│  ├-LinkedList（查询速度慢，增删快）   
│  ├-ArrayList（查询速度快，增删慢）  
│  └-Vector（线程安全的，操作效率低 ）  
│　    └-Stack   
└-Set（无序，不可重复） 
      ├-HashSet（使用了哈希表存取）
      │    └-LinkedHashSet
      └-SortedSet
               └-TreeSet（有序）
Map（键值对）  
├-Hashtable   
├-HashMap   
└-WeakHashMap     

注意：set是在HashMap的基础上实现的，HashSet的存储方式是把HashMap中的Key作为Set的对应存储项。HashMap是非同步的，线程不安全的，Hashtable虽然是同步线程安全的，但是已经过期了。 现在使用ConcurrentHashMap，这个是线程安全同步的

 

这里有一篇关于collection详细介绍的博客：http://skyuck.iteye.com/blog/526358

CollectionUtils类中的方法介绍

package com.self.test1;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.Transformer;

//测试CollectionUtils中的使用方法
public class CollectionUtilsTest {

    public static void main(String[] args) {
        List<String> alist = new ArrayList<String>();
        alist.add("ae");
        alist.add("ae");
        alist.add("b");
        alist.add("c");
        alist.add("c");
        alist.add("d");
        
        List<String> blist = new ArrayList<String>();
        blist.add("1");
        blist.add("2");
        blist.add("3");
        blist.add("ae");
        blist.add("ae");
        blist.add("ae");
        
        /*
         * 两个集合的并集
         */
        
        /*
         * CollectionUtils.union:对两个集合类型的数据进行并集，输出的结果顺序发生了改变，源码中
         * 有这么一段代码Set elts = new HashSet(a)，它把传过来的的集合数据存在在set类型的数据中，
         * HashSet的数据存取是没有顺序的，它是把数据解析成hashcode，根据hashcode进行存取的
         * 
         * 注意：如果两个集合中有元素一样的，合并之后只显示其中某个集合中的元素，并不两个集合中的相同元素都显示。
         * 可以这么说，两个个集合合并之后会显示元素个数是两个集合中的该元素的个数最多的。
         * 例如：两个集合的元素都是一样的，都是[1, 2, 3, ae]，那么合并之后显示结果为：[1, 2, 3, ae]
         * */
        System.out.println("============ CollectionUtils.union ================");
        Collection<String> unionList = CollectionUtils.union(alist, blist);
        System.out.println(unionList.toString());
        
        System.out.println("============ CollectionUtils.getCardinalityMap ================");
        /*
         * CollectionUtils.getCardinalityMap:返回给定的每个唯一元素的映射，以表示该元素在该元素中的出现次数。
        
            List<String> alist = new ArrayList<String>();
            alist.add("ae");
            alist.add("b");
            alist.add("c");
            alist.add("c");
            返回结果：
            {b=1, c=2, ae=1}
        */
        System.out.println(CollectionUtils.getCardinalityMap(alist).toString());
        System.out.println(CollectionUtils.getCardinalityMap(blist).toString());
        
        System.out.println("============ HashSet ================");
        Set elts = new HashSet(alist);
        System.out.println(elts);
        
        /*
         * 两个集合的交集
         */
        Collection<String> intersectionList = CollectionUtils.intersection(alist, blist);
        System.out.println("============ CollectionUtils.intersection ==============");
        System.out.println(intersectionList.toString());
        
        /*
         * 两个集合的补集
         *
         */
        Collection<String> disjunctionList = CollectionUtils.disjunction(alist, blist);
        System.out.println("============ CollectionUtils.disjunction ==============");
        System.out.println(disjunctionList.toString());
        
        /*
         * 两个集合的相减 
         *
         */
        Collection<String> subtractList = CollectionUtils.subtract(alist, blist);
        System.out.println("============ CollectionUtils.subtract ==============");
        System.out.println(subtractList.toString());
        
        /*
         * 判断两个集合是否存在交集
         * return:如果两个指定 collection 中有相同的元素，则返回 true。
         */
        boolean isContainsAny = CollectionUtils.containsAny(alist, blist);
        System.out.println("============ CollectionUtils.containsAny ==============");
        System.out.println("CollectionUtils.containsAny : " + isContainsAny);
        
        //return:如果两个指定 collection 中有相同的元素，则返回 true。
        boolean disjoint = Collections.disjoint(alist, blist);
        System.out.println("Collections.disjoint : " + disjoint);
        
        /*
         * 集合元素的个数,返回存取在Map中
         *
         */
        Map getCardinalityMap = (HashMap) CollectionUtils.getCardinalityMap(alist);
        System.out.println("============ CollectionUtils.getCardinalityMap ==============");
        System.out.println(getCardinalityMap.toString());
        
        /*
         * 判断第一个集合是第二个集合的子集（子集是包括本身的元素的集合，也就是说自己也可以包含自己）
         
             List<String> alist = new ArrayList<String>();
            alist.add("ae");
            alist.add("ae");
            
            List<String> blist = new ArrayList<String>();
            blist.add("ae");
            blist.add("ae");
            
            结果：
            ============ CollectionUtils.isSubCollection ==============
            true
         *
         */
        boolean isSubCollection = CollectionUtils.isSubCollection(blist,alist);
        System.out.println("============ CollectionUtils.isSubCollection ==============");
        System.out.println(isSubCollection);
        
        
        /*
         * 判断第一个集合是第二个集合的真子集（真子集是除本身的元素的集合）
         
             List<String> alist = new ArrayList<String>();
            alist.add("ae");
            alist.add("ae");
            
            List<String> blist = new ArrayList<String>();
            blist.add("ae");
            blist.add("ae");
            
            结果：
            ============ CollectionUtils.isProperSubCollection ==============
            false
         *
         */
        boolean isProperSubCollection = CollectionUtils.isProperSubCollection(blist,alist);
        System.out.println("============ CollectionUtils.isProperSubCollection ==============");
        System.out.println(isProperSubCollection);
        
        /*
         * 判断两个集合是否相等
         *
         */
        boolean isEqualCollection = CollectionUtils.isEqualCollection(alist, blist);
        System.out.println("============ CollectionUtils.isEqualCollection ==============");
        System.out.println(isEqualCollection);
        
        /*
         * 判断元素在某个集合中的个数
         
         源码：
         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;
        }
         
         源码处理的思想挺好的，所以我才把这段源码粘贴出来，先对Collection类型进行判断处理，然后对传过来的参数进行判断处理
         *
         */
        @SuppressWarnings("deprecation")
        int cardinality = CollectionUtils.cardinality("ae", blist);
        System.out.println("============ CollectionUtils.cardinality ==============");
        System.out.println(cardinality);
        
        /*
         * 集合元素中第一个符合查询条件的元素
         *
         */
        @SuppressWarnings("deprecation")
        String find = CollectionUtils.find(alist,ele -> !ele.equals("ae"));
        System.out.println("============ CollectionUtils.find ==============");
        System.out.println(find);
        
        /*
         * 集合元素的过滤
         *
         */
        boolean filter = CollectionUtils.filter(alist,ele -> ele.equals("ae"));
        System.out.println("============ CollectionUtils.filter ==============");
        System.out.println(alist.toString());
        
        /*
         * 集合元素按照给定的格式Transformer进行转化
         *
         */
        System.out.println("============ CollectionUtils.transform ==============");
        List<String> clist = new ArrayList<String>();
        clist.add("20170927101124");
        CollectionUtils.transform(clist,new Transformer(){
            SimpleDateFormat fmt =new SimpleDateFormat("yyyyMMddhhmmss");
            @Override
            public String transform(Object arg0) {
                try {
                    return fmt.parse((String)arg0).toString();
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                return null;
            }});
        System.out.println(clist);
        
        
        /*
         * 集合中符合查询条件的元素的个数
         *
         */
        int countMatches = CollectionUtils.countMatches(alist,ele -> ele.equals("ae"));
        System.out.println("============ CollectionUtils.countMatches ==============");
        System.out.println("CollectionUtils.countMatches : " + countMatches);
        
        //返回指定 collection 中等于指定对象的元素数。与上面的不同之处在于第二个参数，只能是object
        int frequency = Collections.frequency(alist,"ae");
        System.out.println("Collections.frequency : " + frequency);
        
        /*
         * 判断集合中是否符合有查询条件的元素
         *
         */
        boolean exists = CollectionUtils.exists(alist,ele -> ele.equals("ae"));
        System.out.println("============ CollectionUtils.exists ==============");
        System.out.println(exists);
        
        /*
         * 筛选出集合中所有的元素符合查询的条件
         *
         */
        List<String> select = (List<String>) CollectionUtils.select(alist,ele -> ele.equals("ae"));
        System.out.println("============ CollectionUtils.select ==============");
        System.out.println(select.toString());
        
        /*
         * 筛选出集合中所有的元素不符合查询的条件
         *
         */
        List<String> dlist = new ArrayList<String>();
        dlist.add("ae");
        dlist.add("ae");
        dlist.add("b");
        dlist.add("c");
        dlist.add("c");
        dlist.add("d");
        List<String> selectRejected = (List<String>) CollectionUtils.selectRejected(dlist,ele -> ele.equals("b"));
        System.out.println("============ CollectionUtils.selectRejected ==============");
        System.out.println(selectRejected.toString());
        
        /*
         * 集合元素添加，如果添加元素是null，就返回false，不添加，否则添加新元素
         *
         */
        boolean addIgnoreNull =  CollectionUtils.addIgnoreNull(dlist,"db");
        System.out.println("============ CollectionUtils.addIgnoreNull ==============");
        System.out.println(dlist.toString());
        
        /*
         * 将所有指定元素添加到指定 collection 中,
         * 第二个参数中的元素添加到第一个参数集合中尾部
         *
         */
        boolean addAll =  CollectionUtils.addAll(dlist,blist);
        System.out.println("============ CollectionUtils.addAll ==============");
        System.out.println("CollectionUtils.addAll : " + dlist.toString());
        
        
         //用Collections.addAll只能添加元素，不能使用集合，但是可以使用多个元素
         boolean saddAll =  Collections.addAll(dlist,"aaaa");
         System.out.println("Collections.addAll : " + dlist.toString());
        
        
        /*
         * 集合中得到指定下标的元素
         *
         */
        String get =  (String)CollectionUtils.get(alist,1);
        System.out.println("============ CollectionUtils.get ==============");
        System.out.println(get);
        
        /*
         * 集合的大小
         *
         */
        int size =  CollectionUtils.size(alist);
        System.out.println("============ CollectionUtils.size ==============");
        System.out.println(size);
        
        /*
         * 判断集合是否为空
         *
         */
        List<String> elist = new ArrayList<String>();
        /*elist.add("");
        elist.add("ae");
        elist.add("b");
        elist.add("c");
        elist.add("c");
        elist.add("d");*/
        boolean sizeIsEmpty =  CollectionUtils.sizeIsEmpty(elist);
        System.out.println("============ CollectionUtils.sizeIsEmpty ==============");
        System.out.println(sizeIsEmpty);
        
        /*
         * 判断集合是否为空
         *
         */
        boolean isEmpty =  CollectionUtils.isEmpty(elist);
        System.out.println("============ CollectionUtils.isEmpty ==============");
        System.out.println(isEmpty);
        
        /*
         * 判断集合是否为不为空
         *
         */
        boolean isNotEmpty =  CollectionUtils.isNotEmpty(elist);
        System.out.println("============ CollectionUtils.isNotEmpty ==============");
        System.out.println(isNotEmpty);
        
        /*
         * array中的元素从后往前显示
         *
         */
        Object[] array = new Object[]{1,2,3,4,5,5,0,6};
        CollectionUtils.reverseArray(array);
        System.out.println("============ CollectionUtils.reverseArray ==============");
        System.out.println("CollectionUtils.reverseArray : " + Arrays.asList(array));
        /*for(Object obj : array){
            System.out.print(obj + "  ");
        }*/
        
        //反转可以使用：Collections.reverse
        Collections.reverse(blist);
        System.out.println("Collections.reverse : " +blist);
        
        
        /*
         * 如果这个集合BoundedCollection接口，那么返回继承接口中的最大数字，如果没有继承，则返回-1
         */
        /*int maxSize = CollectionUtils.maxSize(alist);
        System.out.println("============ CollectionUtils.maxSize ==============");
        System.out.println(maxSize);*/
        
        /*
         * 第一个集合中的每个元素与第二个集合中的元素进行匹配，
         * 匹配成功就添加到要返回的集合中。返回第一个集合中的元素和第二个集合中元素进行匹配相等的
         * 也就是说返回集合中的元素个数多少个和第一个集合元素个数有关
         
             例如：
             List<String> flist = new ArrayList<String>();
            flist.add("ae");
            
            List<String> hlist = new ArrayList<String>();
            hlist.add("1");
            hlist.add("ae");
            hlist.add("ae");
            
            结果：
            ============ CollectionUtils.retainAll ==============
            [ae]

         *
         */
        List<String> flist = new ArrayList<String>();
        flist.add("ae");
        /*flist.add("ae");
        flist.add("ae");
        flist.add("ae");
        flist.add("b");
        flist.add("c");
        flist.add("c");
        alist.add("d");*/
        
        List<String> hlist = new ArrayList<String>();
        hlist.add("1");
        /*hlist.add("2");
        hlist.add("3");
        hlist.add("ae");*/
        hlist.add("ae");
        hlist.add("ae");
        List<String> retainAll = (List<String>) CollectionUtils.retainAll(flist,hlist);
        System.out.println("============ CollectionUtils.retainAll ==============");
        System.out.println(retainAll);
        
        
        /*
         * 
             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;
            }
            
            1.两个集合求并集，是把两个个集合合并之后会显示元素个数是两个集合中的该元素的个数最多的。
                也就会出现两个集合中元素一样的情况下，只显示其中某个集合中该元素个数最多的那个集合中的
            2.两个集合求交集，与求并集的不同之处就是for中的条件不同（for(int i=0,m=Math.min(getFreq(obj,mapa),getFreq(obj,mapb));i<m;i++)），
                如果两个集合中各自有相同元素的个数大于1，那么交集输出该元素的个数是该元素在两个集合中最少个数的元素。
                    List<String> alist = new ArrayList<String>();
                    alist.add("ae");
                    alist.add("ae");
                    alist.add("b");
                    alist.add("c");
                    alist.add("c");
                    alist.add("d");
                    
                    List<String> blist = new ArrayList<String>();
                    blist.add("1");
                    blist.add("2");
                    blist.add("3");
                    blist.add("ae");
                    blist.add("ae");
                    blist.add("ae");
                    
                    结果：[ae, ae]
                    
            3.两个集合求补集，与求并集的不同之处就是for中的条件不同（ for(int i=0,m=((Math.max(getFreq(obj,mapa),getFreq(obj,mapb)))-(Math.min(getFreq(obj,mapa),getFreq(obj,mapb))));i<m;i++)）
            4.两个集合相减，返回第一个集合里面的不存在第二个集合中的元素
            
         */
        
        
        
    }
    

}

上面就是示例代码。下面是我在写示例代码的时候，需要注意的一些事情。

1.CollectionUtils.union:对两个集合类型的数据进行并集，输出的结果顺序发生了改变，源码中有这么一段代码Set elts = new HashSet(a)，它把传过来的的集合数据存在在set类型的数据中，HashSet的数据存取是没有顺序的，它是把数据解析成hashcode，根据hashcode进行存取的。

注意：如果两个集合中有元素一样的，合并之后只显示其中某个集合中的元素，并不两个集合中的相同元素都显示。可以这么说，两个个集合合并之后会显示元素个数是两个集合中的该元素的个数最多的。例如：两个集合的元素都是一样的，都是[1, 2, 3, ae]，那么合并之后显示结果为：[1, 2, 3, ae]。

2.CollectionUtils.cardinality是判断元素在某个集合中的个数。源码处理的思想挺好的，所以我才把这段源码粘贴出来，先对Collection类型进行判断处理，然后对传过来的参数进行判断处理。

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;
        }

3.CollectionUtils.retainAll：第一个集合中的每个元素与第二个集合中的元素进行匹配， 匹配成功就添加到要返回的集合中。返回第一个集合中的元素和第二个集合中元素进行匹配相等的，也就是说返回集合中的元素个数多少个和第一个集合元素个数有关。

             List<String> flist = new ArrayList<String>();
            flist.add("ae");
            
            List<String> hlist = new ArrayList<String>();
            hlist.add("1");
            hlist.add("ae");
            hlist.add("ae");
            
            结果：
            ============ CollectionUtils.retainAll ==============
            [ae]

4.CollectionUtils.subtract：是两个集合的相减 ，返回第一个集合里面的不存在第二个集合中的元素。

5.关于两个集合的交集、并集、补集的源码分析，这三个方法的源码运用非常巧妙的算法，所以跟大家分享一下。

下面是两个集合的并集源码：

 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;
            }

（1）两个集合求并集，是把两个个集合合并之后会显示元素个数是两个集合中的该元素的个数最多的。也就会出现两个集合中元素一样的情况下，只显示其中某个集合中该元素个数最多的那个集合中的
（2）两个集合求交集，与求并集的不同之处就是for中的条件不同（for(int i=0,m=Math.min(getFreq(obj,mapa),getFreq(obj,mapb));i<m;i++)），如果两个集合中各自有相同元素的个数大于1，那么交集输出该元素的个数是该元素在两个集合中最少个数的元素。

List<String> alist = new ArrayList<String>();
alist.add("ae");
alist.add("ae");
alist.add("b");
alist.add("c");
alist.add("c");
alist.add("d");

List<String> blist = new ArrayList<String>();
blist.add("1");
blist.add("2");
blist.add("3");
blist.add("ae");
blist.add("ae");
blist.add("ae");

结果：[ae, ae]

（3）两个集合求补集，与求并集的不同之处就是for中的条件不同（ for(int i=0,m=((Math.max(getFreq(obj,mapa),getFreq(obj,mapb)))-(Math.min(getFreq(obj,mapa),getFreq(obj,mapb))));i<m;i++)）

Collections类中方法使用在第一次的代码中有写到。