高效的找出兩個List中的不同元素

原文作者暫時沒有找到，如果您是原文作者，請聯繫我，我及時更正。謝謝。
PS：如果有問題，請及時指出，謝謝！

問題：

有List<String> list1和List<String> list2,兩個集合各有上萬個元素，怎樣取出兩個集合中不同的元素?

解決辦法1：

遍歷兩個集合：

package com.czp.test;

import java.util.ArrayList;
import java.util.List;

public class TestList {

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            list1.add("test"+i);
            list2.add("test"+i*2);
        }
        getDiffrent(list1,list2);
        //輸出：total times 2566454675
    }

    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        List<String> diff = new ArrayList<String>();
        for(String str:list1)
        {
            if(!list2.contains(str))
            {
                diff.add(str);
            }
        }
        System.out.println("total times "+(System.nanoTime()-st));
        return diff;
    }
}

千萬不要採用這種方法，總共要循環的次數是兩個List的size相乘的積，從輸出看耗時也是比較長的，那麼我們有沒有其他的方法呢？當然有。

解決辦法2：

採用List提供的retainAll（）方法：

package com.czp.test;

import java.util.ArrayList;
import java.util.List;

public class TestList {

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            list1.add("test"+i);
            list2.add("test"+i*2);
        }
        getDiffrent(list1,list2);
        //輸出：total times 2566454675
        getDiffrent2(list1,list2);
        //輸出：getDiffrent2 total times 2787800964
    }

    /**
     * 獲取連個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent2(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        list1.retainAll(list2);
        System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
        return list1;
    }

    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        List<String> diff = new ArrayList<String>();
        for(String str:list1)
        {
            if(!list2.contains(str))
            {
                diff.add(str);
            }
        }
        System.out.println("getDiffrent total times "+(System.nanoTime()-st));
        return diff;
    }
}

很遺憾，這種方式雖然只要幾行代碼就搞定，但是這個卻更耗時，查看retainAll（）的源碼:

 public boolean retainAll(Collection<?> c) {
    boolean modified = false;
    Iterator<E> e = iterator();
    while (e.hasNext()) {
        if (!c.contains(e.next())) {
        e.remove();
        modified = true;
        }
    }
    return modified;
    }

無需解釋這個耗時是必然的，那麼我們還有沒有更好的辦法呢？仔細分析以上兩個方法中我都做了mXn次循環，其實完全沒有必要循環這麼多次，我們的需求是找出兩個List中的不同元素,那麼我可以這樣考慮：用一個map存放lsit的所有元素，其中的key爲lsit1的各個元素，value爲該元素出現的次數,接着把list2的所有元素也放到map裏，如果已經存在則value加1，最後我們只要取出map裏value爲1的元素即可，這樣我們只需循環m+n次，大大減少了循環的次數。

解決辦法3：

package com.czp.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestList {

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            list1.add("test"+i);
            list2.add("test"+i*2);
        }
        getDiffrent(list1,list2);
        //輸出：total times 2566454675
        getDiffrent2(list1,list2);
        //輸出：getDiffrent2 total times 2787800964
        getDiffrent3(list1,list2);
        //輸出：getDiffrent3 total times 61763995
    }
    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent3(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
        List<String> diff = new ArrayList<String>();
        for (String string : list1) {
            map.put(string, 1);
        }
        for (String string : list2) {
            Integer cc = map.get(string);
            if(cc!=null)
            {
                map.put(string, ++cc);
                continue;
            }
            map.put(string, 1);
        }
        for(Map.Entry<String, Integer> entry:map.entrySet())
        {
            if(entry.getValue()==1)
            {
                diff.add(entry.getKey());
            }
        }
        System.out.println("getDiffrent3 total times "+(System.nanoTime()-st));
        return list1;
    }

    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent2(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        list1.retainAll(list2);
        System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
        return list1;
    }

    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        List<String> diff = new ArrayList<String>();
        for(String str:list1)
        {
            if(!list2.contains(str))
            {
                diff.add(str);
            }
        }
        System.out.println("getDiffrent total times "+(System.nanoTime()-st));
        return diff;
    }
}

顯然，這種方法大大減少耗時，是方法1的1/4，是方法2的1/40，這個性能的提升時相當可觀的，但是，這不是最佳的解決方法，觀察方法3我們只是隨機取了一個list作爲首次添加的標準，這樣一旦我們的list2比list1的size大，則我們第二次put時的if判斷也會耗時，做如下改進：

解決辦法3（優化版）：

package com.czp.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestList {

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            list1.add("test"+i);
            list2.add("test"+i*2);
        }
        getDiffrent(list1,list2);
        getDiffrent2(list1,list2);
        getDiffrent3(list1,list2);
        getDiffrent4(list1,list2);
//        getDiffrent total times 2789492240
//        getDiffrent2 total times 3324502695
//        getDiffrent3 total times 24710682
//        getDiffrent4 total times 15627685
    }
    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent4(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
        List<String> diff = new ArrayList<String>();
        List<String> maxList = list1;
        List<String> minList = list2;
        if(list2.size()>list1.size())
        {
            maxList = list2;
            minList = list1;
        }
        for (String string : maxList) {
            map.put(string, 1);
        }
        for (String string : minList) {
            Integer cc = map.get(string);
            if(cc!=null)
            {
                map.put(string, ++cc);
                continue;
            }
            map.put(string, 1);
        }
        for(Map.Entry<String, Integer> entry:map.entrySet())
        {
            if(entry.getValue()==1)
            {
                diff.add(entry.getKey());
            }
        }
        System.out.println("getDiffrent4 total times "+(System.nanoTime()-st));
        return diff;

    }
    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent3(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
        List<String> diff = new ArrayList<String>();
        for (String string : list1) {
            map.put(string, 1);
        }
        for (String string : list2) {
            Integer cc = map.get(string);
            if(cc!=null)
            {
                map.put(string, ++cc);
                continue;
            }
            map.put(string, 1);
        }
        for(Map.Entry<String, Integer> entry:map.entrySet())
        {
            if(entry.getValue()==1)
            {
                diff.add(entry.getKey());
            }
        }
        System.out.println("getDiffrent3 total times "+(System.nanoTime()-st));
        return diff;
    }

    /**
     * 獲取連個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent2(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        list1.retainAll(list2);
        System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
        return list1;
    }

    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        List<String> diff = new ArrayList<String>();
        for(String str:list1)
        {
            if(!list2.contains(str))
            {
                diff.add(str);
            }
        }
        System.out.println("getDiffrent total times "+(System.nanoTime()-st));
        return diff;
    }
}

這裏對連個list的大小進行了判斷，小的在最後添加，這樣會減少循環裏的判斷，性能又有了一定的提升，正如一位朋友所說，編程是無止境的，只要你認真去思考了，總會找到更好的方法！
非常感謝binglian的指正，針對List有重複元素的問題，做以下修正，首先明確一點，兩個List不管有多少個重複，只要重複的元素在兩個List都能找到，則不應該包含在返回值裏面，所以在做第二次循環時，這樣判斷：如果當前元素在map中找不到，則肯定需要添加到返回值中，如果能找到則value++，遍歷完之後diff裏面已經包含了只在list2裏而沒在list2裏的元素，剩下的工作就是找到list1裏有list2裏沒有的元素，遍歷map取value爲1的即可：
複製代碼

最終修訂版：

package com.czp.test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class TestList {

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        for (int i = 0; i < 10000; i++) {
            list1.add("test"+i);
            list2.add("test"+i*2);
        }
        getDiffrent(list1,list2);
        getDiffrent3(list1,list2);
        getDiffrent5(list1,list2);
        getDiffrent4(list1,list2);
        getDiffrent2(list1,list2);

//        getDiffrent3 total times 32271699
//        getDiffrent5 total times 12239545
//        getDiffrent4 total times 16786491
//        getDiffrent2 total times 2438731459

    }
    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent5(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
         List<String> diff = new ArrayList<String>();
         List<String> maxList = list1;
         List<String> minList = list2;
         if(list2.size()>list1.size())
         {
             maxList = list2;
             minList = list1;
         }
         Map<String,Integer> map = new HashMap<String,Integer>(maxList.size());
         for (String string : maxList) {
             map.put(string, 1);
         }
         for (String string : minList) {
             if(map.get(string)!=null)
             {
                 map.put(string, 2);
                 continue;
             }
             diff.add(string);
         }
         for(Map.Entry<String, Integer> entry:map.entrySet())
         {
             if(entry.getValue()==1)
             {
                 diff.add(entry.getKey());
             }
         }
        System.out.println("getDiffrent5 total times "+(System.nanoTime()-st));
        return diff;

    }
    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent4(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
        List<String> diff = new ArrayList<String>();
        List<String> maxList = list1;
        List<String> minList = list2;
        if(list2.size()>list1.size())
        {
            maxList = list2;
            minList = list1;
        }
        for (String string : maxList) {
            map.put(string, 1);
        }
        for (String string : minList) {
            Integer cc = map.get(string);
            if(cc!=null)
            {
                map.put(string, ++cc);
                continue;
            }
            map.put(string, 1);
        }
        for(Map.Entry<String, Integer> entry:map.entrySet())
        {
            if(entry.getValue()==1)
            {
                diff.add(entry.getKey());
            }
        }
        System.out.println("getDiffrent4 total times "+(System.nanoTime()-st));
        return diff;

    }
    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent3(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        Map<String,Integer> map = new HashMap<String,Integer>(list1.size()+list2.size());
        List<String> diff = new ArrayList<String>();
        for (String string : list1) {
            map.put(string, 1);
        }
        for (String string : list2) {
            Integer cc = map.get(string);
            if(cc!=null)
            {
                map.put(string, ++cc);
                continue;
            }
            map.put(string, 1);
        }
        for(Map.Entry<String, Integer> entry:map.entrySet())
        {
            if(entry.getValue()==1)
            {
                diff.add(entry.getKey());
            }
        }
        System.out.println("getDiffrent3 total times "+(System.nanoTime()-st));
        return diff;
    }

    /**
     * 獲取連個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent2(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        list1.retainAll(list2);
        System.out.println("getDiffrent2 total times "+(System.nanoTime()-st));
        return list1;
    }

    /**
     * 獲取兩個List的不同元素
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getDiffrent(List<String> list1, List<String> list2) {
        long st = System.nanoTime();
        List<String> diff = new ArrayList<String>();
        for(String str:list1)
        {
            if(!list2.contains(str))
            {
                diff.add(str);
            }
        }
        System.out.println("getDiffrent total times "+(System.nanoTime()-st));
        return diff;
    }
}

完整的代碼:

 1 package com.czp.util;
 2 
 3 import java.util.Collection;
 4 import java.util.HashMap;
 5 import java.util.HashSet;
 6 import java.util.LinkedList;
 7 import java.util.Map;
 8 
 9 /**
10  * 該類提供對集合類的高效操作
11  * @author Czp
12  *
13  */
14 
15 public class CollectionUtil {
16 
17     /**
18      * 不允許實例化
19      */
20     private CollectionUtil() {
21     }
22     
23     /**
24      *  獲取兩個集合的不同元素
25      * @param collmax
26      * @param collmin
27      * @return
28      */
29     @SuppressWarnings({ "rawtypes", "unchecked" })
30     public static Collection getDiffent(Collection collmax,Collection collmin)
31     {
32         //使用LinkeList防止差異過大時,元素拷貝
33         Collection csReturn = new LinkedList();
34         Collection max = collmax;
35         Collection min = collmin;
36         //先比較大小,這樣會減少後續map的if判斷次數
37         if(collmax.size()<collmin.size())
38         {
39             max = collmin;
40             min = collmax;
41         }
42         //直接指定大小,防止再散列
43         Map<Object,Integer> map = new HashMap<Object,Integer>(max.size());
44         for (Object object : max) {
45             map.put(object, 1);
46         }
47         for (Object object : min) {
48             if(map.get(object)==null)
49             {
50                 csReturn.add(object);
51             }else{
52                 map.put(object, 2);
53             }
54         }
55         for (Map.Entry<Object, Integer> entry : map.entrySet()) {
56             if(entry.getValue()==1)
57             {
58                 csReturn.add(entry.getKey());
59             }
60         }
61         return csReturn;
62     }
63     /**
64      *  獲取兩個集合的不同元素,去除重複
65      * @param collmax
66      * @param collmin
67      * @return
68      */
69     @SuppressWarnings({ "rawtypes", "unchecked" })
70     public static Collection getDiffentNoDuplicate (Collection collmax,Collection collmin)
71     {
72         return new HashSet(getDiffent(collmax, collmin));
73     }
74 }

結束語:

本文章由於是遷移過來的，本人也忘了是否驗證過。如果有錯誤，一定要指出啊，非常感謝！！！