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類中方法使用在第一次的代碼中有寫到。