MaxList模塊主要是對Java集合大數據去重的相關介紹。
背景: 最近在項目中遇到了List集合中的數據要去重，大概一個2500萬的數據，開始存儲在List中，需要跟一個2萬的List去去重。
直接兩個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()方法的原因)
從上面的代碼可以看到當Iterator.remove方法導致ArrayList列表發生變化時，他會更新cursor來同步這一變化。但其他方式導致的ArrayList變化，Iterator是無法感知的。ArrayList自然也不會主動通知Iterator們，那將是一個繁重的工作。Iterator到底還是做了努力：為了防止狀態不一致可能引發的無法設想的后果，Iterator會經常做checkForComodification檢查，以防有變。如果有變，則以異常拋出，所以就出現了上面的異常。
如果對正在被迭代的集合進行結構上的改變（即對該集合使用add、remove或clear方法），那么迭代器就不再合法（並且在其后使用該迭代器將會有ConcurrentModificationException異常被拋出）.
如果使用迭代器自己的remove方法，那么這個迭代器就仍然是合法的。
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());
}
遍歷過程中去重
個人最為推薦的一種,因為效率最高，也能達到功能的需要。
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
總結
通過上述測試我們可以看出，有時候我們排重的時候，不一定要拍完重再對排重后的數據進行遍歷，可以在遍歷的過程中進行排重，注意用來排重的那個集合放到Set中，
可以是HashSet,或者其他Set(推薦使用HashSet),因為Set的contains效率更高，比list高很多。
然后考慮到如果非要拿到去重后的list，考慮使用方案3《List結合Set去重(不是直接對list進行刪除，而是組裝新list，考慮到list刪除效率低)》，通過測試，這種方法效率也是非常的高。
與方案4相比，稍微慢一點點。
對於上述方案1，測試也使用過組裝新list的方式，而不是list.remove。但是效率還是比較慢。
這是實際工作中總結出來的經驗。希望對大家有幫助！
歡迎大家來交流！
演示圖
項目文件結構截圖
大數據List去重
注：本文著作權歸作者，由demo大師代發，拒絕轉載，轉載需要作者授權