计算两个集合交集的方法为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来说，千万*千万 次循环。。。几个小时都跑不出结果吧。
710
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
