小徐带你解决List 的removeAll方法效率问题的解决

前言

目前小徐，实习在一个还算不错的公司，毕竟也是一个上市企业，主要做财务软件方面比较牛逼，

自称在亚太地区NO1,咱也不知道，咱也不敢说，老老实实做咱们的小菜鸡，努力学习，

早日称为大佬，哈哈！！

实际工作中遇到的小问题：

记录今天在公司中遇到的一个问题，业务问题描述：在重新询价时，可以指定邀请供应商，

重新询价可以新增邀请的供应商，但是在重新询价的时候，原先邀请的供应商不能取消邀请，

如果取消邀请了原先的供应商在发布的时候不能发布成功，提供一个

校验提示显示原先邀请的供应商没有被邀请的供应商名。

问题转换 类似于一下问题

这个问题描述类似于，有两个集合，集合1(原先邀请的供应商名)有 0-100000 Long 类型，

集合2(最新邀请的供应商名)有 100-200000 long类型，找出 0-100的元素(没有被邀请的原供应商名)。

方案一：使用List的removeAll()方法 效率太低

package com.aliwo.list;

import java.util.LinkedList;
import java.util.List;

/**
 * package_name:com.aliwo.list
 *
 * @author:徐亚远 Date:2020/9/15 21:42
 * 项目名:thread-projects
 * Description:TODO
 * Version: 1.0
 **/

public class OneTest {
    public static void main(String[] args) {
        Long startTime = System.currentTimeMillis();
        List<Long> longList = new LinkedList<>();
        for (Long i = 0L;i<100000;i++){
            longList.add(i);
        }
        List<Long> longList1 = new LinkedList<>();
        for (Long i = 100L;i<200000;i++){
            longList1.add(i);
        }
        longList.removeAll(longList1);
        System.out.println(longList);
        Long endTime = System.currentTimeMillis();
        System.out.println("花费时间 17193:" +(endTime-startTime));

    }
}

注意使用List的removeAll()方法的效率问题

	使用List的removeAll()方法，虽然问题解决了但是效率还有问题，数据量大的时候，
	
	会出现问题，会花费大量的时间，影响产品的体验效果，所以我想到了另一种解决方法。

方案二：改用从list中add数据 效率还是低

package com.aliwo.list;

import java.util.LinkedList;
import java.util.List;

/**
 * package_name:com.aliwo.list
 *
 * @author:徐亚远 Date:2020/9/15 21:55
 * 项目名:thread-projects
 * Description:TODO
 * Version: 1.0
 **/

public class TwoTest {
    public static void main(String[] args) {
        Long startTime = System.currentTimeMillis();
        List<Long> longList = new LinkedList<>();
        for (Long i = 0L;i<100000;i++){
            longList.add(i);
        }
        List<Long> longList1 = new LinkedList<>();
        for (Long i = 100L;i<200000;i++){
            longList1.add(i);
        }
        List<Long> resultList = new LinkedList<>();
        for (Long l : longList){
            if (!longList1.contains(l)){
                resultList.add(l);
            }
        }
        System.out.println(resultList);
        Long endTime = System.currentTimeMillis();
        System.out.println("花费时间 16864:" +(endTime-startTime));
    }
}

注意使用List的add方法的效率问题

想到了从list中add数据要比从list中remove数据的速度快，所以用了此种方法,但是效果不明显

和原来的removeAll方法效果差不多，所以想到了第三种方法如下。

方案三：运用set可以去重 还可以接受

运用Set可以去重这一特性。将longList1中的元素逐个添加到由destinationSet 生成的Set中，

如果Set.add(e)为true，说明e应该保留到结果中，否则放弃e。因为longList1中可能存在重复的元素，

因此想到用Map来保存source中的元素与其在longList1中出现的次数。

结果令我大跌眼镜，性能的提高有好几个数量级，代码如下：

package com.aliwo.list;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

/**
 * package_name:com.aliwo.list
 *
 * @author:徐亚远 Date:2020/9/15 22:13
 * 项目名:thread-projects
 * Description:TODO
 * Version: 1.0
 **/
 //百万级别会产生效率问题，十万级别还没有事情
public class ThreeTest {
    public static void main(String[] args) {
        Long startTime = System.currentTimeMillis();
        List<Long> longList = new LinkedList<>();
        for (Long i = 0L;i<100000;i++){
            longList.add(i);
        }
        List<Long> longList1 = new LinkedList<>();
        for (Long i = 100L;i<200000;i++){
            longList1.add(i);
        }
        List<Long> resultList = new LinkedList<>();
        Set<Long> destinationSet = new HashSet<>(longList1);
        System.out.println("set:" +destinationSet );
        for (Long l : longList){
            if (!destinationSet .contains(l)){
                resultList.add(l);
            }
        }
        System.out.println(resultList);
        Long endTime = System.currentTimeMillis();
        System.out.println("花费时间 set 44 效率最高:" +(endTime-startTime));
    }
}

注意：

	当数据达到百万级别的时候，效率还是有问题，花费时间还是接受不了不过对于大型公司来说，
	
	都会有解决的方案，针对我们公司特定的业务场景，在此场景中不会出现百万界别的数据，

	所以使用第三种方案是最好的，那么是因为什么那：是因为：Map.containsKey()和Set.contains()的
	
	速度快，要比list.contains()快的太多了。