高效率的集合交集（差集）处理方式

最新推荐文章于 2021-12-08 17:40:46 发布
最新推荐文章于 2021-12-08 17:40:46 发布
阅读量988 收藏
点赞数
分类专栏： JavaSE Java对象之集合
原文链接：https://blog.csdn.net/Yunwei_Zheng/article/details/105955777
版权

高效率的集合交集（差集）处理方式

https://blog.csdn.net/Yunwei_Zheng/article/details/105955777

https://blog.csdn.net/dulinanaaa/article/details/85234279

/**
     * 交集（差集）处理方式(String)
     * @param list1
     * @param list2
     * @return
     */
    private List<String> getRetainAllString(List<String> list1, List<String> list2){
        List<String> r = new ArrayList<>();
        Map<String, String> map1 = list1.stream().collect(Collectors.toMap(s -> s, Function.identity()));
        list2.stream().forEach(s -> {
            String ss = map1.get(s);
            if (ss != null) {
                r.add(ss);
            }
        });
        return r;
    }

    /**
     * 交集（差集）处理方式(Integer)
     * @param list1
     * @param list2
     * @return
     */
    private List<Integer> getRetainAllInteger(List<Integer> list1, List<Integer> list2){
        List<Integer> r = new ArrayList<>();
        Map<Integer, Integer> map1 = list1.stream().collect(Collectors.toMap(s -> s, Function.identity()));
        list2.stream().forEach(s -> {
            Integer ss = map1.get(s);
            if (ss != null) {
                r.add(ss);
            }
        });
        return r;
    }


    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        // 初始化数据
        for (int i = 0; i < 60000; i++) {
            list1.add("test" + i);
            list2.add("test" + i * 3);
        }
        //System.out.println(list1);
        //System.out.println(list2);
        System.out.println("-------------------------");
        long t = System.currentTimeMillis();
        List<String> needAddOpenidList = getRemoveAllString(list1, list2);
        System.out.println(needAddOpenidList);
        System.out.println(System.currentTimeMillis() - t);
        System.out.println(needAddOpenidList.size());
        System.out.println("------------------");
        long t1 = System.currentTimeMillis();
        list1.removeAll(list2);
        System.out.println(System.currentTimeMillis() - t1);
        System.out.println(list1.size());
        /*List<String> needAddOpenidList1 = getRemoveAllString(list2, list1);
        System.out.println(needAddOpenidList1);*/
    }


    private static List<String> getRemoveAllString(List<String> allOpenidList, List<String> dbOpenidList) {
        if (dbOpenidList != null && !dbOpenidList.isEmpty()) {
            Map<String, String> dataMap = new HashMap<>();
            for (String id : dbOpenidList) {
                dataMap.put(id, id);
            }
            List<String> newList = new ArrayList<>();
            for (String id : allOpenidList) {
                if (!dataMap.containsKey(id)) {
                    newList.add(id);
                }
            }
            return newList;
        } else {
            return allOpenidList;
        }
    }

    private static List<Integer> getRemoveAllInteger(List<Integer> allOpenidList, List<Integer> dbOpenidList) {
        if (dbOpenidList != null && !dbOpenidList.isEmpty()) {
            Map<Integer, Integer> dataMap = new HashMap<>();
            for (Integer id : dbOpenidList) {
                dataMap.put(id, id);
            }
            List<Integer> newList = new ArrayList<>();
            for (Integer id : allOpenidList) {
                if (!dataMap.containsKey(id)) {
                    newList.add(id);
                }
            }
            return newList;
        } else {
            return allOpenidList;
        }
    }

 

 /**
     * 产品服务收款方式
     * @param params
     * @return
     */
    @Override
    public List<MemberProductPaymentDTO> getMemberProductPayment(QueryDTO params) {
        QueryDTO dto = getParams(params);
        List<MemberProductPaymentDTO> yptList = extendedMapper.getMemberProductPayment(dto);
        List<MemberProductPaymentEasDTO> easList = extendedEasMapper.getMemberProductPayment(dto);
        List<MemberProductPaymentDTO> list = new ArrayList<>();
        if (CollectionUtils.isEmpty(yptList) && CollectionUtils.isEmpty(easList)) {
            return list;
        }
        List<Integer> list1 = yptList.stream().map(MemberProductPaymentDTO::getId).collect(Collectors.toList());
        List<Integer> list2 = easList.stream().map(MemberProductPaymentEasDTO::getIdEas).collect(Collectors.toList());
        Map<Integer, MemberProductPaymentDTO> mapYpt = yptList.stream().collect(Collectors.toMap(w -> w.getId(), w -> w));
        Map<Integer, MemberProductPaymentEasDTO> mapEas = easList.stream().collect(Collectors.toMap(w -> w.getIdEas(), w -> w));
        Integer checkResult = params.getCheckResult();
        //查询状态为 全部或正确
        if (!Objects.equals(CheckTypeEnum.NO.getValue(), checkResult)) {
            //求交集
            List<Integer> retainAllInteger = getRetainAllInteger(list1, list2);
            for (int i = 0; i < retainAllInteger.size(); i++) {
                Integer s = retainAllInteger.get(i);
                MemberProductPaymentDTO memberProductPaymentDTO = mapYpt.get(s);
                MemberProductPaymentEasDTO memberProductPaymentEasDTO = mapEas.get(s);
                if (memberProductPaymentEasDTO != null) {
                    BeanUtils.copyProperties(memberProductPaymentEasDTO, memberProductPaymentDTO);
                }
                memberProductPaymentDTO.setCheckResult(CheckTypeEnum.YES.getValue());
                memberProductPaymentDTO.setDateSort(memberProductPaymentDTO.getPayTime());
                list.add(memberProductPaymentDTO);
            }
        }
        //查询状态为 全部或有误
        if (!Objects.equals(CheckTypeEnum.YES.getValue(), checkResult)) {
            //云平台有，EAS没有
            List<Integer> removeAllInteger1 = getRemoveAllInteger(list1, list2);
            for (int i = 0; i < removeAllInteger1.size(); i++) {
                Integer s = removeAllInteger1.get(i);
                MemberProductPaymentDTO memberProductPaymentDTO = mapYpt.get(s);
                memberProductPaymentDTO.setCheckResult(CheckTypeEnum.NO.getValue());
                memberProductPaymentDTO.setCheckRemarks(Consts.EASDES);
                memberProductPaymentDTO.setDateSort(memberProductPaymentDTO.getPayTime());
                list.add(memberProductPaymentDTO);
            }
            //云平台没有，EAS有
            List<Integer> removeAllInteger2 = getRemoveAllInteger(list2, list1);
            for (int i = 0; i < removeAllInteger2.size(); i++) {
                Integer s = removeAllInteger2.get(i);
                MemberProductPaymentDTO memberProductPaymentDTO = new MemberProductPaymentDTO();
                MemberProductPaymentEasDTO memberProductPaymentEasDTO = mapEas.get(s);
                if (memberProductPaymentEasDTO != null) {
                    BeanUtils.copyProperties(memberProductPaymentEasDTO, memberProductPaymentDTO);
                }
                memberProductPaymentDTO.setCheckResult(CheckTypeEnum.NO.getValue());
                memberProductPaymentDTO.setCheckRemarks(Consts.YPTDES);
                memberProductPaymentDTO.setDateSort(memberProductPaymentEasDTO.getPayTimeEas());
                list.add(memberProductPaymentDTO);
            }
        }
        //排序和分页
        if (CollectionUtils.isNotEmpty(list)) {
            list = list.stream().sorted(Comparator.comparing(MemberProductPaymentDTO::getDateSort).reversed()).collect(Collectors.toList());
        }
        return list;
    }

    /**
     * 查询转换
     * @param params
     * @return
     */
    private QueryDTO getParams(QueryDTO params){
        QueryDTO pa = new QueryDTO();
        BeanUtils.copyProperties(params, pa);
        pa.emptyPage();
        return pa;
    }

    /**
     * 交集处理方式(String)
     * @param list1
     * @param list2
     * @return
     */
    private List<String> getRetainAllString(List<String> list1, List<String> list2){
        List<String> r = new ArrayList<>();
        Map<String, String> map1 = list1.stream().collect(Collectors.toMap(s -> s, Function.identity()));
        list2.stream().forEach(s -> {
            String ss = map1.get(s);
            if (ss != null) {
                r.add(ss);
            }
        });
        return r;
    }

    /**
     * 交集处理方式(Integer)
     * @param list1
     * @param list2
     * @return
     */
    private List<Integer> getRetainAllInteger(List<Integer> list1, List<Integer> list2){
        List<Integer> r = new ArrayList<>();
        Map<Integer, Integer> map1 = list1.stream().collect(Collectors.toMap(s -> s, Function.identity()));
        list2.stream().forEach(s -> {
            Integer ss = map1.get(s);
            if (ss != null) {
                r.add(ss);
            }
        });
        return r;
    }

    /**
     * 差集处理方式(String)
     * @param list1
     * @param list2
     * @return
     */
    private static List<String> getRemoveAllString(List<String> list1, List<String> list2) {
        if (CollectionUtils.isNotEmpty(list2)) {
            Map<String, String> dataMap = new HashMap<>(list2.size());
            for (String id : list2) {
                dataMap.put(id, id);
            }
            List<String> newList = new ArrayList<>();
            for (String id : list1) {
                if (!dataMap.containsKey(id)) {
                    newList.add(id);
                }
            }
            return newList;
        } else {
            return list1;
        }
    }

    /**
     * 差集处理方式(Integer)
     * @param list1
     * @param list2
     * @return
     */
    private static List<Integer> getRemoveAllInteger(List<Integer> list1, List<Integer> list2) {
        if (CollectionUtils.isNotEmpty(list2)) {
            Map<Integer, Integer> dataMap = new HashMap<>(list2.size());
            for (Integer id : list2) {
                dataMap.put(id, id);
            }
            List<Integer> newList = new ArrayList<>();
            for (Integer id : list1) {
                if (!dataMap.containsKey(id)) {
                    newList.add(id);
                }
            }
            return newList;
        } else {
            return list1;
        }
    }

 

我们在业务上难免会遇到集合交集的处理，这边总结了几种方式比较，然后寻求最优的方式。当然如果集合数据比较少的情况下，选取的方式基本都能满足需求，但是如果在数据量比较大的情况下呢？如果选取的方式不好，那么效率就会及其的低下。下面我们就集中方式展开分析。

ArrayList原生接口retainAll(c)方式

    public static void main(String[] args) {
        
        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        List<String> r = new ArrayList<>();
        // 初始化数据
        for (int i = 0; i < 30000; i++) {
            list1.add("test" + i);
            list2.add("test" + i * 3);
        }
        System.out.println("添加完成");
        long t = System.currentTimeMillis();
        list1.retainAll(list2);
        System.out.println(System.currentTimeMillis() - t);
    }

我们执行上述代码，我们一个集合3w的数据，耗时时间基本都是在9s左右。

通过list遍历contains判定方式

  public static void main(String[] args) {


        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        List<String> r = new ArrayList<>();
        for (int i = 0; i < 30000; i++) {
            list1.add("test" + i);
            list2.add("test" + i * 3);
        }
        System.out.println("添加完成");
        long t = System.currentTimeMillis();

        list1.stream().forEach(s->{
            if(list2.contains(s)){
                r.add(s);
            }
        });

        System.out.println(System.currentTimeMillis() - t);

    }

跟原生api的方式比较，效率差不多，通过代码分析，原生api也是采用的是集合遍历然后contains判定的。

List转Map通过key来判定是否交叉

public static void main(String[] args) {


        List<String> list1 = new ArrayList<String>();
        List<String> list2 = new ArrayList<String>();
        List<String> r = new ArrayList<>();
        for (int i = 0; i < 30000; i++) {
            list1.add("test" + i);
            list2.add("test" + i * 3);
        }
        System.out.println("添加完成");
        long t = System.currentTimeMillis();


        Map<String, String> map1 = list1.stream().collect(toMap(s -> s, Function.<String>identity()));
        list2.stream().forEach(s -> {
            String ss = map1.get(s);
            if (ss != null) {
                r.add(ss);
            }
        });

        System.out.println(System.currentTimeMillis() - t);
    }

执行代码跟上面两种方式相比，效率是相当的高，两个数组都在3W级别的数量集，基本保持在100ms左右即可完成。

原文链接：https://blog.csdn.net/Yunwei_Zheng/article/details/105955777

最是那一低头的温柔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
A、B两个整数集合，设计一个算法求他们的交集，尽可能的高效
明月松间照，清泉石上流！
10-12 1427
思路1：排序法 　　对集合A和集合B进行排序（升序，用快排，平均复杂度O(N*logN)），设置两个指针p和q，同时指向集合A和集合B的最小值，不相等的话移动*p和*q中较小值的指针，相等的话同时移动指针p和q，并且记下相等的数字，为交集的元素之一，依次操作，直到其中一个集合没有元素可比较为止。 　　优点：操作简单，容易实现。 　　缺点：使用的排序算法不当，会耗费大量的时间，比如
转：A、B两个整数集合，设计一个算法求他们的交集，尽可能的高效。
weixin_33826268的博客
10-21 304
A、B两个整数集合，设计一个算法求他们的交集，尽可能的高效。 转载于:https://www.cnblogs.com/kira2will/p/4039565.html
集合 求全集 高效 算法 性能对比 与 分析 JAVA
Ximerr的博客
07-28 747
问题： 两个集合，分别含有一定数量的元素，如何快速得到两个集合的合集？ 举例： 给定两个集合List<String> list1和List<String> list2，假定两个集合分别具有m和n个元素，要求得到他们的全集（实际上就是去重复）。 说明： 1.以String作为集合中元素的类型，如果是自定义的数据结构，需要重写equals方法 2.输入参数：第一个集合list1，第二个集合list2 3.输出参数：合集的集合结果 实现： 方法一：集合减法 全集、交集.
sql server 交集,差集的用法详解
09-08
总结来说，SQL Server的交集、差集和并集运算提供了灵活的数据处理方式，使我们能够从多个数据源中精确地获取所需信息。熟练掌握这些运算，对于优化查询性能和提升数据分析能力至关重要。在实际工作中，根据需求选择...
python获得两个数组交集、并集、差集的方法
09-22
在Python编程语言中，操作列表(list)是常见的数据处理任务之一。列表是Python中的序列类型，...在处理大量数据时，使用集合操作可以显著提高代码执行效率。理解并熟练掌握这些操作对于编写高效的Python代码至关重要。
PHP实现对数组简单求交集，差集，并集功能示例
10-19
PHP本身支持多种数组操作方法，这些操作方法可以以直观、简洁的方式完成复杂的数据处理任务。对于任何希望深入学习PHP的开发者来说，熟悉这些基础函数是非常必要的。通过阅读本文，读者应该能够更好地理解PHP中数组...
SQLServer 数据集合的交、并、差集运算
09-11
在SQLServer中，数据集合的交、并、差集运算是一种强大的数据操作方式，它允许用户根据特定条件合并和比较两个或多个数据表中的记录。这些运算符在数据分析、报表生成以及数据清洗过程中非常常见。在SQLServer 2005...
集合的并交差运算
10-24
堆排序法在处理大规模数据时具有较高的效率，特别是当数据已经部分有序时。然而，对于小型集合，直接使用哈希表或其他数据结构可能更快，因为它们可以在常数时间内完成这些集合运算。 总之，堆排序法在求解集合的...
利用顺序表求集合的并集
06-24
int main(){ list a; list b; list c; int x=100,y=100,i=1,j=1; int k=1; cout<<"请输入A集合中的数，以数字0结束："<>x; if(x==0) break; a.insert(i,x); i++; cout<<x<<" "; } cout<<endl; cout<<"请输入B集合中的数，以数字0结束："<>y; if(y==0) break; b.insert(j,y); j++; cout<<y<<" "; } cout<<endl; i=1;j=1; while(i<a.length()+1&&jy){ j++; } else if(x=y){ c.insert(k,x); i++; j++; k++; } else{ c.insert(k,x); k++; i++; } } k=1; cout<<"A交B={"; while(k<c.length()+1){ c.get_element(k,x); k++; cout<<x; } cout<<"}"<<endl; return 0; }
顺序表求并集和交集(C++)
10-12
顺序表求并集和交集，用C++实现的，定义了一个顺序表的类。
求两个集合的交集
蓬莱道人的博客
09-27 4402
1、题目描述 给定两个集合set1和set2，求这两个集合的交集。 2、解题思路 （1）暴力破解 这个方法最简单，直接暴力枚举，假设第一个几个set1的元素个数为 m ，第二个集合set2的元素个数为 n，那么这种方法的时间复杂度为O（ m * n ） （2）排序 对两个集合分别进行排序，时间复杂度为O（ m log m）和O（ nlog n），接着...
集合算法求交集——set_intersection
嵌入式
07-06 2720
集合算法求交集——set_intersection 功能描述： 求两个容器的交集 函数原型： set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest); // 求两个集合的交集 // 注意:两个集合必须是有序序列 // beg1 容器1开始迭代器 // end1 容...
算法-最快速度求两个数组之交集算法
littlewhitevg的博客
09-13 2826
1. DSU（并查集） 条件:需要查询小范围的数据集合，不包含特殊数字。同时数字>=1。 思路：使用数组hash。index代表集合中的数。value为代表集合。 class DSU { int[] parent; //可初始化大小 public DSU() { parent = new int[10001]; for (int i = 0; i <= 10000; ++i)
Java-两个较大的List快速取交集、差集
itfound的博客
12-08 3095
Java-两个较大的List快速取交集、差集
高效比较两个list集合中的差集
热门推荐
王大不明白总有一天会明白
03-20 1万+
List&lt;Department&gt; different = new ArrayList&lt;Department&gt;(); List&lt;Department&gt; maxList = list1; List&lt;Department&gt; minList = list2; if(list2.size()&gt;list1.size()) { maxList = l...
Java List集合交集、差集、并集计算
gmHappy
03-16 1360
需求描述 两个集合之间进行交集、差集、并集计算。 在日常工作中前端可能传过来一个数据集合，需要和数据库中查出的集合进行比较，判断前端的集合中那些数据是需要在数据库新增、那些数据是需要从数据库中删除、那些数据需要在数据库中变更（此示例的变更依据是name） 具体实现 package cn.net.hylink; import java.util.ArrayList; import java.util.List; import java.util.Map; import java.util.stream.
oracle交集 并集 差集
最新发布
10-30
其中并集可以使用UNION和UNION ALL关键字实现，UNION ALL不去重，效率高，而UNION去重，效率低；交集使用INTERSECT关键字实现；差集使用MINUS关键字实现。在进行集合操作时，各个列的数据类型必须对应，保持一致，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值