精华内容
下载资源
问答
  • JAVA获取两个数据量较大的ArrayList的交集、差集以及并集,记录一下以便查阅。JAVA获取两个数据量较大的ArrayList的交集、差集以及并集,记录一下以便查阅。JAVA获取两个数据量较大的ArrayList的交集、差集以及并集...
  • 下面小编就为大家分享一篇java8 集合差集、并集、交集的实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Java两个List差集

    千次阅读 2019-11-02 21:42:29
    1、创建测试类(TestList5.java) package com.jeff; import java.util.ArrayList; import java.util.List; public class TestList5 { public static void main(String[] args) { List<String> l1 = new...

    1、创建测试类(TestList5.java)

    package com.jeff;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class TestList5 {
    
    	public static void main(String[] args) {
    		List<String> l1 = new ArrayList<String>();
    		l1.add("A");
    		l1.add("B");
    		l1.add("C");
    		l1.add("D");
    		l1.add("E");
    		l1.add("F");
    		List<String> l2 = new ArrayList<String>();
    		l2.add("E");
    		l2.add("F");
    		l2.add("G");
    		l2.add("H");
    		l2.add("I");
    		l2.add("J");
    		// List差集
    		l1.removeAll(l2);
    		System.out.println("List差集:" + l1);
    	}
    
    }
    
    

    2、控制台输出结果
    在这里插入图片描述

    展开全文
  • 利用java8的新特性 java8 lambda表达式流操作不影响原始list对象; 对象类型处理 List<Student> list1 = new ArrayList<>(); list1.add(new Student("name100","100")); list1.add(new Student(...

    一.利用java8的新特性
    java8 lambda表达式流操作不影响原始list对象;

    1. 对象类型处理
     List<Student> list1 = new ArrayList<>();
            list1.add(new Student("name100","100"));
            list1.add(new Student("name102","102"));
            list1.add(new Student("name103","103"));
    
            List<Student> list2 = new ArrayList<>();
            list2.add(new Student("name103","103"));
            list2.add(new Student("name104","104"));
    
            Set<Student> set1 = new HashSet<>(list1);
    
            Set<Student> set2 = new HashSet<>(list2);
    
    	1).交集
    
            List<Student> intersection = list1.stream().filter(set2::contains).collect(toList());
            System.out.println("---得到交集 intersection---");
            intersection.parallelStream().forEach(System.out::println);
    
    	2).差集(list1--->list2)
    
    List<Student> reduce1 = list1.stream().filter(item -> !set2.contains(item)).collect(toList());
            System.out.println("---得到差集 reduce1 (list1 - list2)---");
            reduce1.parallelStream().forEach(System.out::println);
    
    	3).差集(list2--->list1)
    
    List<Student> reduce2 = list2.stream().filter(item -> !set1.contains(item)).collect(toList());
            System.out.println("---得到差集 reduce2 (list2 - list1)---");
            reduce2.parallelStream().forEach(System.out::println);
    
    	4).并集
    
    List<Student> listAll = list1.parallelStream().collect(toList());
            List<Student> listAll2 = list2.parallelStream().collect(toList());
            listAll.addAll(listAll2);
            System.out.println("---得到并集 listAll---");
            listAll.parallelStream().forEach(System.out::println);
    
    	5).去重并集
    
    set1.addAll(set2);
            List<Student> listDistinctAll = new ArrayList<>(set1);
            System.out.println("---得到去重并集 listDistinctAll---");
            listDistinctAll.parallelStream().forEach(System.out::println);
    
    1. 简单类型的处理
    List<String> list1 = new ArrayList<>();
            list1.add("1");
            list1.add("2");
            list1.add("3");
    
            List<String> list2 = new ArrayList<>();
            list2.add("3");
            list2.add("4");
    
            Set<String> set1 = new HashSet<>(list1);
    
            Set<String> set2 = new HashSet<>(list2);
    
    	1).交集
    
    List<String> intersection = list1.stream().filter(set2::contains).collect(toList());
            System.out.println("---得到交集 intersection---");
            intersection.parallelStream().forEach(System.out::println);
    
    	2).差集(list1 - list2)
    
    List<String> reduce1 = list1.stream().filter(item -> !set2.contains(item)).collect(toList());
            System.out.println("---得到差集 reduce1 (list1 - list2)---");
            reduce1.parallelStream().forEach(System.out::println);
    
    	3).差集(list2 - list1)
    
    List<String> reduce2 = list2.stream().filter(item -> !set1.contains(item)).collect(toList());
            System.out.println("---得到差集 reduce2 (list2 - list1)---");
            reduce2.parallelStream().forEach(System.out::println);
    
    	4).并集
    
    List<String> listAll = list1.parallelStream().collect(toList());
            List<String> listAll2 = list2.parallelStream().collect(toList());
            listAll.addAll(listAll2);
            System.out.println("---得到并集 listAll---");
            listAll.parallelStream().forEach(System.out::println);
    
    	5).去重并集
    
    set1.addAll(set2);
            List<String> listDistinctAll = new ArrayList<>(set1);
            System.out.println("---得到去重并集 listDistinctAll---");
            listDistinctAll.parallelStream().forEach(System.out::println);
    

    二.利用ArrayList自带的方法

    List<String> list1 = new ArrayList<String>();
            list1.add("1");
            list1.add("2");
    
            List<String> list2 = new ArrayList<String>();
            list2.add("2");
            list2.add("3");
    
    	1). 差集(List1中有的但是List2中没有的元素)
    
     list1.removeAll(list2);
            System.out.println(list1);
    
    	2). 并集(不去重)
    
     list1.addAll(list2);
            System.out.println(list1);
    
    	3). 并集(去重)
    
     list1.removeAll(list2);
            list1.addAll(list2);
            System.out.println(list1);
    
    	4). 交集
    
    list1.retainAll(list2);
            System.out.println(list1);
    
    展开全文
  • 两个集合之间进行交集、差集、并集计算。 在日常工作中前端可能传过来一个数据集合,需要和数据库中查出的集合进行比较,判断前端的集合中那些数据是需要在数据库新增、那些数据是需要从数据库中删除、那些数据需要...

    需求描述

    两个集合之间进行交集、差集、并集计算。

    在日常工作中前端可能传过来一个数据集合,需要和数据库中查出的集合进行比较,判断前端的集合中那些数据是需要在数据库新增、那些数据是需要从数据库中删除、那些数据需要在数据库中变更(此示例的变更依据是name

    具体实现

    package cn.net.hylink;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map
    展开全文
  • 获取firstArrayList和secondArrayList的交集(两个集合相同的部分)、差集两个集合不同的部分)以及并集(两个集合全并后的数据(不包含重复数据)) import java.util.Set; import java.util.List; import java...

    获取firstArrayList和secondArrayList的交集(两个集合相同的部分)、差集(两个集合不同的部分)以及并集(两个集合全并后的数据(不包含重复数据))

    import java.util.Set;
    import java.util.List;
    import java.util.HashSet;
    import java.util.TreeSet;
    import java.util.Iterator;
    import java.util.ArrayList;
    import java.util.LinkedList;
     
    public class getSet {
        
        public static void main(String args[]) {
            getList();
        }
        
        // 获取两个ArrayList的差集、交集、去重并集(数据量大小不限制)
        private static void getList() {
            List<String> firstArrayList = new ArrayList<String>();
            List<String> secondArrayList = new ArrayList<String>();
            List<String> defectList = new ArrayList<String>();//差集List
            List<String> collectionList = new ArrayList<String>();//交集List
            List<String> unionList = new ArrayList<String>();//去重并集List
            try {
                firstArrayList.add("aaa");
                firstArrayList.add("bbb");
                firstArrayList.add("ccc");
                firstArrayList.add("ddd");
     
                secondArrayList.add("bbb");
                secondArrayList.add("ccc");
                secondArrayList.add("eee");
                // 获取差集
                defectList = receiveDefectList(firstArrayList, secondArrayList);
                Iterator<String> defectIterator = defectList.iterator();
                System.out.println("===================差集===================");
                while(defectIterator.hasNext()) {
                    System.out.println(defectIterator.next());
                }
                // 获取交集
                collectionList = receiveCollectionList(firstArrayList, secondArrayList);
                Iterator<String> collectionIterator = collectionList.iterator();
                System.out.println("===================交集===================");
                while(collectionIterator.hasNext()) {
                    System.out.println(collectionIterator.next());
                }
                // 获取去重并集
                unionList = receiveUnionList(firstArrayList, secondArrayList);
                Iterator<String> unionIterator = unionList.iterator();
                System.out.println("===================去重并集===================");
                while(unionIterator.hasNext()) {
                    System.out.println(unionIterator.next());
                }
            }catch(Exception e) {
                e.printStackTrace();
            }
        }
        
        /**
         * @方法描述:获取两个ArrayList的差集
         * @param firstArrayList 第一个ArrayList
         * @param secondArrayList 第二个ArrayList
         * @return resultList 差集ArrayList
         */
        public static List<String> receiveDefectList(List<String> firstArrayList, List<String> secondArrayList) {
            List<String> resultList = new ArrayList<String>();
            LinkedList<String> result = new LinkedList<String>(firstArrayList);// 大集合用 linkedlist 删除值得 
            HashSet<String> othHash = new HashSet<String>(secondArrayList);// 小集合用hashset 包含的  
            Iterator<String> iter = result.iterator();// 采用Iterator迭代器进行数据的操作  
            while(iter.hasNext()){  
                if(othHash.contains(iter.next())){  
                    iter.remove();            
                }     
            }  
            resultList = new ArrayList<String>(result);
            return resultList;
        }
        
        /**
         * @方法描述:获取两个ArrayList的交集
         * @param firstArrayList 第一个ArrayList
         * @param secondArrayList 第二个ArrayList
         * @return resultList 交集ArrayList
         */
        public static List<String> receiveCollectionList(List<String> firstArrayList, List<String> secondArrayList) {
            List<String> resultList = new ArrayList<String>();
            LinkedList<String> result = new LinkedList<String>(firstArrayList);// 大集合用linkedlist  
            HashSet<String> othHash = new HashSet<String>(secondArrayList);// 小集合用hashset  
            Iterator<String> iter = result.iterator();// 采用Iterator迭代器进行数据的操作  
            while(iter.hasNext()) {
                if(!othHash.contains(iter.next())) {  
                    iter.remove();            
                }     
            }
            resultList = new ArrayList<String>(result);
            return resultList;
        }
        
        /**
         * @方法描述:获取两个ArrayList的去重并集
         * @param firstArrayList 第一个ArrayList
         * @param secondArrayList 第二个ArrayList
         * @return resultList 去重并集ArrayList
         */
        public static List<String> receiveUnionList(List<String> firstArrayList, List<String> secondArrayList) {
            List<String> resultList = new ArrayList<String>();
            Set<String> firstSet = new TreeSet<String>(firstArrayList);
            for(String id : secondArrayList) {
                // 当添加不成功的时候 说明firstSet中已经存在该对象
                firstSet.add(id);
            }
            resultList = new ArrayList<String>(firstSet);
            return resultList;
        }
    }

    转载:https://blog.csdn.net/zwdwinter/article/details/88411041

    展开全文
  • 原始对象 List<HrProbationMainPO> hrProbationMainList =new ArrayList<...获取交集对象 * stream 转换成流 (只有变成流才能操作) * filter 封装判断条件(如果true 则收集到结果中,false则不收集)
  • java如何求两个集合的交集和并集呢??其实java的API中已经封装了方法。今天写个简单的例子测试一下:(例子中以java.util.LinkedList为例) package org.suk; import java.text.MessageFormat; import java.util...
  • public class ExtractIdUtils { public static Map<String, List<Long>> extractList(List<Long> newIds, List<Long> oldIds) { List<Long>... tempList.retainA.
  • java两个集合差集

    2014-07-19 21:19:00
    publicstaticvoidmain(String[]args){Setset=newHashSet();Setset1=newHashSet();set.add("sanny");set.add("mary");set.add("bill");set.add("tom");set.add("tony");set.add("mark");set.add("smith"...
  • Java两个Set集合的交集、差集和并集 一、求交集 注:场景是读取两个文件,把文件内容放到Set中,求两个文件之间的共同元素。在这里只写对Set的操作。 public static void main(String[] args) throws Exception { ...
  • //两集合差集 List<String> reduce2 = Arrays.asList(split).stream().filter(item -> !Arrays.asList(ticketType.split(",")).contains(item)).collect(Collectors.toList()); //集合转数组 String[] ...
  • 集合操作直接使用remove来比较两个集合差集,数据量达到十几万时,效率比较慢,推荐使用一下方式. package com.lcw.adapter; import java.util.*; /** * @author: craywen * @date: 2021-02-22 16:07 * @desc: ...
  • 一种复杂度为O(1)获取两个List差集的算法(JAVA)
  • public static void main(String[] args){ Listlist = ... //输出集合中元素 } } 运行程序,从集合 list 中移除 list1 中的内容,遍历集合 list,结果为“从我做起”; list.removeAll()不传参数为删除所有集合内容;
  •   经常遇到一些集合类之间的过滤数据、求合集之类的问题,在此以List为例,毕竟在数据库中取数据后,我们使用比较多的是List集合进行操作。 模板 代码 public static void main(String[] args) { List<String&...
  • java8 集合对象求差集、交集

    千次阅读 2019-09-28 01:34:23
    差集 List<TFridCard> list = cardLiStOut.stream().filter(item -> !msgModel.getPayload().stream().map(e -> e.getTagname()).collect(Collectors.toList()).contains(item.getUniqueCode())).collect...
  • java8 两个list 求差集

    千次阅读 2019-07-09 17:27:00
    业务场景:调用同步接口获取当前...调用接口获取的数据集合 List<AccountVo> list = response.getData().getItems(); 本地查询出来的账户集合 List<Account> towList = accountRepository.findAl...
  • JAVA集合差集操作

    2021-08-27 16:17:52
    返回两个集合差异的不可修改视图。 返回的集合包含set1包含但set2不包含的所有元素。 set2也可能包含set1不存在的元素; 这些都被忽略了。 返回集合的迭代顺序与set1的迭代顺序匹配。 如果set1和set2是基于不同等价...
  • java两个集合取交集、并集与差集

    千次阅读 2020-07-08 14:49:18
    // 差集 System.out.println(CollectionUtils.subtract(list1,list2)); // 交集的补集 System.out.println(CollectionUtils.disjunction(list1,list2)); System.out.println("==============================="); /...
  • import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.List... * 用最少循环求两个数组的交集、差集、并集  *   * @author ZQC  *  */ public class Test {  ...
  • 1、测试代码 ... import org.junit.Test;...import java.util.ArrayList; import java.util.List; import java.util.stream.Collectors; /** * @author LH * @date 2020-04-28 18:11 */ publ...
  • 【精】【Java8】===两个List集合取交集、并集、差集

    万次阅读 多人点赞 2018-08-14 19:03:30
    oldList(上次查询到的权限列表),currList(当前查询到的权限列表),比对两个list找出:移除和增加的权限加以标识(1--增加,-1--删除)返回。 原逻辑处理方法:循环currList,如果oldList中不包含即为增加的...
  • 比较两个list集合差集

    千次阅读 2019-04-13 18:33:15
    1. 工具类 ...import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public class ChaJi { public static List<Integer> temp(List<Inte...
  • java8 判断两个List集合交集 差集

    千次阅读 2019-10-22 14:10:24
    public static void main(String[] args) { List<String> list1 = new ArrayList(); list1.add("1"); list1.add("2"); list1.add("3"); list1.add("5");... List<String> list2 = new ...同时适用于对象实体类集合

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,138
精华内容 5,255
关键字:

java获取两个集合的差集

java 订阅