快速從2個List集合中找出相同/不同元素

最近剛好涉及到從2個不同集合中找出不同的元素的需求，以下為測試代碼

1、利用 apache collection 工具內中的方法，附上坐標

<dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.2.1</version>
</dependency>

collection 工具包中給出出了2個比較方便的工具方法

1、找共同的元素 org.apache.commons.collections.ListUtils.retainAll(Collection, Collection) 附上源碼如下

    public static List removeAll(Collection collection, Collection remove) {
        List list = new ArrayList();
        for (Iterator iter = collection.iterator(); iter.hasNext();) {
            Object obj = iter.next();
            if (remove.contains(obj) == false) {
                list.add(obj);
            }
        }
        return list;
    }

 

2、找出不同的元素 org.apache.commons.collections.ListUtils.removeAll(Collection, Collection) 附上源碼如下

    public static List retainAll(Collection collection, Collection retain) {
        List list = new ArrayList(Math.min(collection.size(), retain.size()));

        for (Iterator iter = collection.iterator(); iter.hasNext();) {
            Object obj = iter.next();
            if (retain.contains(obj)) {
                list.add(obj);
            }
        }
        return list;
    }

附上測試 demo 代碼

    public static void main(String[] args) {
        // 生成集合1
        List<Integer> list1 = Lists.newArrayList();
        for (int i = 0; i < 100000; i++) {
            list1.add(i);
        }
        // 生成集合 2
        List<Integer> list2 = Lists.newArrayList();
        for (int i = 0; i < 100001; i++) {
            list2.add(i);
        }
        long start = System.currentTimeMillis();
        // 開始分離
        List<Integer> list = ListUtils.removeAll(list2, list1);
        long end = System.currentTimeMillis();
        System.out.println(list);
        System.out.println(end - start);
        // 總執行次數 100000*100001
    }

執行結果如下

[100000]
4027

通過源碼可以看出 集合迭代過程執行了100000*100001 次，隨着數據量增加，速度將越來越慢，所以有了如下的優化方案， 付上代碼

    public static void main(String[] args) {
        // 生成集合1
        List<Integer> list1 = Lists.newArrayList();
        for (int i = 0; i < 100000; i++) {
            list1.add(i);
        }
        // 生成集合2
        List<Integer> list2 = Lists.newArrayList();
        for (int i = 0; i < 100001; i++) {
            list2.add(i);
        }
        long start = System.currentTimeMillis();
        //開始分離
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        for (Integer integer : list2) {
            map.put(integer, 1);
        }
        for (Integer integer : list1) {
            map.put(integer, 2);
        }
        List<Integer> list3 = new ArrayList<Integer>();
        Set<Entry<Integer, Integer>> entrySet = map.entrySet();
        for (Entry<Integer, Integer> entry : entrySet) {
            Integer value = entry.getValue();
            if (Objects.equals(1, value)) {
                list3.add(entry.getKey());
            }
        }
        //結束分離
        long end = System.currentTimeMillis();
        System.out.println(list3);
        System.out.println(end - start);
        //總執行次數 100000+100001+100001
    }

執行結果

[100000]
33

差距非常明顯，且我們分析執行次數可以看出，通過map執行迭代次數為100000+100001+100001 迭代次數減少很多，速度自然上來了

總結：當數據量不大的情況下，通過ListUtils.removeAll 的方式還是非常推薦，畢竟不用自己造輪子，但是如果數據量達到百萬級以上時，推薦使用Map的方式