计算两个集合交集的方法为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来说,千万*千万 次循环。。。几个小时都跑不出结果吧。