大數據List去重

時間 2019-12-01

標籤數據 list 简体版

原文原文鏈接

代碼地址以下：
http://www.demodashi.com/demo/12587.htmlhtml

MaxList模塊主要是對Java集合大數據去重的相關介紹。java

背景: 最近在項目中遇到了List集合中的數據要去重，大概一個2500萬的數據，開始存儲在List中，須要跟一個2萬的List去去重。ide

直接兩個List去重

說到去重，稍微多講一點啊，去重的時候有的小夥伴可能直接對2500萬List foreach循環後直接刪除,
其實這種是錯誤的(java.util.ConcurrentModificationException)，你們能夠本身去試一下；(注: for循環遍歷刪除不報錯，可是效率低，不推薦使用)
首先你須要去看下foreach和迭代器的實現。foreach的實現就是用到了迭代器，因此你在foreach的時候對list進行刪除操做，
迭代器Iterator沒法感知到list刪除了，因此會報錯。直接貼代碼解釋下。測試

ArrayList中Iterator的實現:大數據

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    @Override
    @SuppressWarnings("unchecked")
    public void forEachRemaining(Consumer<? super E> consumer) {
        Objects.requireNonNull(consumer);
        final int size = ArrayList.this.size;
        int i = cursor;
        if (i >= size) {
            return;
        }
        final Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length) {
            throw new ConcurrentModificationException();
        }
        while (i != size && modCount == expectedModCount) {
            consumer.accept((E) elementData[i++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

經過上述的ArrayList裏面的Iterator迭代器的實現咱們能夠看到:
基本上ArrayList採用size屬性來維護自已的狀態，而Iterator採用cursor來來維護自已的狀態。
當你直接在foreach裏面對list進行刪除操做，size出現變化時，cursor並不必定可以獲得同步，除非這種變化是Iterator主動致使的。(調用list.iterator()方法的緣由)ui

從上面的代碼能夠看到當Iterator.remove方法致使ArrayList列表發生變化時，他會更新cursor來同步這一變化。但其餘方式致使的ArrayList變化，Iterator是沒法感知的。ArrayList天然也不會主動通知Iterator們，那將是一個繁重的工做。Iterator到底仍是作了努力：爲了防止狀態不一致可能引起的沒法設想的後果，Iterator會常常作checkForComodification檢查，以防有變。若是有變，則以異常拋出，因此就出現了上面的異常。
若是對正在被迭代的集合進行結構上的改變（即對該集合使用add、remove或clear方法），那麼迭代器就再也不合法（而且在其後使用該迭代器將會有ConcurrentModificationException異常被拋出）.
若是使用迭代器本身的remove方法，那麼這個迭代器就仍然是合法的。this

public static void deWeightList(List<String> des, List<String> sourse){
        if(sourse == null || sourse.size() <= 0){
            return;
        }l
        Iterator<String> listStr = sourse.iterator();
        while (listStr.hasNext()){
            String item = listStr.next();
            for (String ditem: des) {
                if(item.equals(ditem)){
                    listStr.remove();
                    break;
                }
            }

        }
        logger.info("after deWight list size: " + sourse.size());
}

List結合Set去重

public static void deWeightList(Set<String> des, List<String> sourse) {
        if (sourse == null || sourse.size() <= 0) {
            return;
        }
        Iterator<String> listStr = sourse.iterator();
        while (listStr.hasNext()) {
            String item = listStr.next();
            if (des.contains(item)) {
                listStr.remove();
            }
        }
        logger.info("after deWight list size: " + sourse.size());
}

List結合Set去重(不是直接對list進行刪除，而是組裝新list，考慮到list刪除效率低)

public static void deWeightListByNewList(Set<String> des, List<String> sourse) {
    if (sourse == null || sourse.size() <= 0) {
        return;
    }
    Iterator<String> listStr = sourse.iterator();
    List<String> existList = new ArrayList<String>();
    while (listStr.hasNext()) {
        String item = listStr.next();
        if(!des.contains(item)){
            //TODO 對去重後的數據進行邏輯操做，不必定要刪除，能夠換個思路（是否能夠直接邏輯操做，不必定非要再把數據寫進集合後，而後遍歷集合在進行邏輯操做）
            existList.add(item); //改爲添加進新的list，考慮到list的刪除效率慢(非要獲得刪除後的集合的狀況下，不然走else)
        }
//            if (des.contains(item)) {
//                //listStr.remove(); //考慮到list的刪除效率慢，此種方法對於大數據集合來講不合適
//            }
    }
    sourse.clear();
    sourse = existList;
    logger.info("after deWight list size: " + sourse.size());
}

遍歷過程當中去重

我的最爲推薦的一種,由於效率最高，也能達到功能的須要。code

for (String item: maxArrayList) {
    if(testSet.contains(item)){
        //TODO
    }
}

測試結果以下

下面是1000萬的list和20000的list去重兩種方式所花的時間,能夠看出使用set去重的效率要高不少。

1.list結合list去重時間:
14:52:02,408 INFO  [RunTest:37] start test list:17-11-07 14:52:02
14:59:49,828 INFO  [ListUtils:66] after deWight list size: 9980000
14:59:49,829 INFO  [RunTest:39] end test list:17-11-07 14:59:49

2.list結合set去重時間:
14:59:53,226 INFO  [RunTest:44] start test set:17-11-07 14:59:53
15:01:30,079 INFO  [ListUtils:80] after deWight list size: 9980000
15:01:30,079 INFO  [RunTest:46] end test set:17-11-07 15:01:30

下面是2500萬的list和20000的list去重兩種方式所花的時間,能夠看出使用set去重的效率要更加的高，(數據量越大越明顯)。
我的對set的大小爲1500萬也進行了測試，方案3,4的效率也是很是的高。

1.list結合list去重時間:
15:17:47,114 INFO  [RunTest:35] start test list, start time: 17-11-07 15:17:47
15:49:04,876 INFO  [ListUtils:57] after deWight list size: 24980000
15:49:04,877 INFO  [RunTest:39] end test list, end time: 17-11-07 15:49:04

2.list結合set去重時間:
15:49:17,842 INFO  [RunTest:44] start test set, start time: 17-11-07 15:49:17
15:53:22,716 INFO  [ListUtils:71] after deWight list size: 24980000
15:53:22,718 INFO  [RunTest:48] end test set, end time: 17-11-07 15:53:22

3. List結合Set去重(不是直接對list進行刪除，而是組裝新list，考慮到list刪除效率低)
17:18:44,583 INFO  [RunTest:57] start test set, start time: 17-11-22 17:18:44
17:18:54,628 INFO  [ListUtils:92] after deWight list size: 23500000
17:18:54,628 INFO  [RunTest:61] end test set, end time: 17-11-22 17:18:48

4.遍歷過程當中結合set去重:(我的最爲推薦的緣由之一，效率高到使人爽到不行)
15:17:45,762 INFO  [RunTest:24] start test foreach list directly, start time: 17-11-07 15:17:45
15:17:47,114 INFO  [RunTest:32] end test foreach list directly, end time: 17-11-07 15:17:47