03-大数据量取并交集为什么用Set而不是List

月光螳螂

已于 2024-02-22 17:45:22 修改

阅读量22

点赞数

分类专栏：解决方案篇文章标签： list windows 数据结构

于 2023-10-20 15:22:29 首次发布

本文链接：https://blog.csdn.net/weixin_45768501/article/details/133947400

版权

解决方案篇专栏收录该内容

3 篇文章 0 订阅

订阅专栏

计算两个集合交集的方法为retainAll，计算两个集合差集的方法为removeAll，通常我们在使用这两个方法的时候不会遇到问题，因为我们进行集合运算的两个List数据不会有太多，listA.retainAll(listB); 这行代码的执行用不了几毫秒。就算列表数据有几万，差不多一秒左右也能执行完，但是当两个列表数据超过10万时，你就会发现，retainAll或者removeAll两个方法执行变得缓慢起来，数据继续增加的话，两个方法就会更加异常缓慢。

一、看一下下面的示例：

import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

public class SetOperation {
private static Logger logger = LoggerFactory.getLogger(SetOperation.class);

/**
 * 集合的运算方法用时测试
 */
@Test
public void setOperation() {
    List listA = new ArrayList();
    List listB = new ArrayList();

    initData(listA, listB);
    logger.info("计算交集：");
    listA.retainAll(listB);
    logger.info(String.valueOf(listA.size()));

    initData(listA, listB);
    logger.info("计算差集：");
    listA.removeAll(listB);
    logger.info(String.valueOf(listA.size()));
}

private void initData(List listA, List listB) {
    listA.clear();
    listB.clear();
    for (int i = 0; i &lt; 100000; i++) {
        listA.add(i);
        listB.add(i + 50000);
    }
}

}

初始化两个ArrayList，容量为10万，一个集合的值为0-100000，另一个集合的值为50000-150000，分别计算交集和差集，下面为日志输出：

15:02:44.112 [main] INFO SetOperation - 计算交集：
15:02:52.398 [main] INFO SetOperation - 50000
15:02:52.403 [main] INFO SetOperation - 计算差集：
15:02:59.085 [main] INFO SetOperation - 50000

 
 
 
 1
2
3
4

可以看到交集计算用时8s，差集计算用时7s。
现在把集合容量改为30万，扩大3倍，看一下计算结果：

15:10:19.378 [main] INFO SetOperation - 计算交集：
15:11:31.111 [main] INFO SetOperation - 250000
15:11:31.120 [main] INFO SetOperation - 计算差集：
15:12:46.899 [main] INFO SetOperation - 50000

 
 
 
 1
2
3
4

这一次两个30万数据的集合，交集计算用时1分12秒，差集计算用时1分15秒。
集合容量改为50万数据，看一下计算结果：

15:16:03.960 [main] INFO SetOperation - 计算交集：
15:19:55.668 [main] INFO SetOperation - 450000
15:19:55.681 [main] INFO SetOperation - 计算差集：
15:24:00.087 [main] INFO SetOperation - 50000

 
 
 
 1
2
3
4

用时在4分钟左右。
集合容量改为100万数据，计算结果：

15:29:52.174 [main] INFO SetOperation - 计算交集：
15:48:00.021 [main] INFO SetOperation - 950000
15:48:00.043 [main] INFO SetOperation - 计算差集：
16:05:50.071 [main] INFO SetOperation - 50000

 
 
 
 1
2
3
4

用时为18分钟左右！

二、把代码稍微调整一下，两个列表改为HashSet，再来看一下执行的效果。

代码改动如下：

@Test
public void setOperation() {
    List listA = new ArrayList();
    List listB = new ArrayList();
initData(listA, listB);
logger.info("计算交集：");
Set setA = new HashSet(listA);
Set setB = new HashSet(listB);
setA.retainAll(setB);
logger.info(String.valueOf(setA.size()));

initData(listA, listB);
logger.info("计算差集：");
setA = new HashSet(listA);
setB = new HashSet(listB);
setA.removeAll(setB);
logger.info(String.valueOf(setA.size()));

}

直接看100万数据的计算结果：

16:36:27.005 [main] INFO SetOperation - 计算交集：
16:36:27.772 [main] INFO SetOperation - 950000
16:36:27.798 [main] INFO SetOperation - 计算差集：
16:36:28.661 [main] INFO SetOperation - 50000

 
 
 
 1
2
3
4

用时1s！！！这1s时间还包括两个100万的List转Set，单看retainAll，removeAll两个方法的话，用时应该只需不到100毫秒。跟ArrayList的18分钟相比，那真是一个天上，一个地下。

三、那究竟为什么两个100万数据的ArrayList求交集用20分钟，两个100万数据的HashSet只需几十毫秒的时间?ArrayList为什么慢，HashSet又为什么快？
这要从两个容器类的实现来看了，ArrayList是基于数组实现的，HashSet是基于HashMap实现的，利用HashMap的key不重复，底层用HashMap保存的数据。
看一下ArrayList.retainAll()方法的源码

	public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }
private boolean batchRemove(Collection&lt;?&gt; c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r &lt; size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) {
            System.arraycopy(elementData, r,
                             elementData, w,
                             size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i &lt; size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

可以看到交集运算时，for循环遍历列表，判断另一个列表是否包含每一个元素，调用contains方法去判断，ArrayList的contains方法，看一下源码，也是for循环遍历判断是否相等。因为ArrayList是基于数组，两个数组怎么求交集呢？肯定是类似下面的代码的：

int[] arrayA = new int[1000000];
int[] arrayB = new int[1000000];
int[] retainArray = new int[1000000];
int num = 0;
for (int i = 0; i < arrayA.length; i++) {
    int a = arrayA[i];
    for (int j = 0; j < arrayB.length; j++) {
        int b = arrayB[j];
        if (a == b) {
            retainArray[num] = a;
            num++;
        }
    }
}

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14

两个100万长度的数组求交集，两次for循环，是需要判断100万*100万=1万亿次的！这样的嵌套for循环是笛卡尔积的循环次数，1万亿次的循环判断用时20分钟现在再看，也是正常的。通常1s的时间内，像a==b这样的代码，执行一亿行这样的代码没问题，可1万亿行代码，可就不是几秒时间的事了。好，现在搞清楚ArrayList为什么慢了，因为它求交集和差集，是两个for循环嵌套，随着集合数据的增多，循环次数是指数倍增长，用时增加也是指数倍了。

HashSet两个100万数据的集合求交集为什么几十毫秒就能搞定？看一下HashSet的源码，HashSet继承AbstractSet，AbstractSet继承AbstractCollection，retainAll方法在AbstractCollection类中定义的，如下：

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

 
 
 
 1
2
3
4
5
6
7
8
9
10
11
12

这里用的iterator遍历集合，调用另一个集合的contains方法判断是否包含每一个元素，哎？大家该问了，这和ArrayList的retainAll方法不是一样的吗！Arraylist用for循环遍历，调用contains判断是否包含；HashSet用iterator遍历，也是调用contains判断是否包含。对，这里是一样的，关键在contains方法这！看一下HashSet的contains方法源码，

    public boolean contains(Object o) {
        return map.containsKey(o);
    }

 
 
 
 1
2
3

因为HashSet底层数据结构是HashMap，contains方法调用的是HashMap的containsKey方法，而HashMap的containsKey方法判断key是否存在不是用的遍历！ HashMap底层数据结构是基于数组+链表，数组存储的是HashMap的键值对Node<K,V>，通过对key进行哈希算法得到Node节点在数组中的具体位置，如果不同的key计算的哈希值相同，那么追加在已存在节点的后面，数组的该位置存放的就是一个链表。HashMap的实现原理这里就不做详细介绍了，对HashMap来说判断key是否存在，只需要判断哈希计算后的坐标位置是否存在节点即可，不需要遍历整个Node数组的。

对HashSet来说，交集计算是一次for循环，两个100万长度的HashSet集合，求交集或者差集，只用遍历100万次，这也是为什么它只需要几十毫秒就能得出结果的原因。即使数据有几千万，HashSet对两个千万长度的集合求交集和差集，1秒之内得出结果也是没问题的，可对ArrayList来说，千万*千万次循环。。。几个小时都跑不出结果吧。

月光螳螂

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
03-大数据量取并交集为什么用Set而不是List

HashMap底层数据结构是基于数组+链表，数组存储的是HashMap的键值对Node，通过对key进行哈希算法得到Node节点在数组中的具体位置，如果不同的key计算的哈希值相同，那么追加在已存在节点的后面，数组的该位置存放的就是一个链表。这要从两个容器类的实现来看了，ArrayList是基于数组实现的，HashSet是基于HashMap实现的，利用HashMap的key不重复，底层用HashMap保存的数据。这一次两个30万数据的集合，交集计算用时1分12秒，差集计算用时1分15秒。
复制链接

扫一扫