十万以上数据的两个集合进行交集,差集运算,ArrayList为什么特别慢?HashSet为什么效率如此高?

计算两个集合交集的方法为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 < 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

可以看到交集计算用时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

这一次两个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

用时在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

用时为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

用时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<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < 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 < 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++;
        }
    }
}

两个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;
    }

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

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

因为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来说,千万*千万 次循环。。。几个小时都跑不出结果吧。

  • 9
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值