精华内容
下载资源
问答
  • 前言java8里最大亮点是lambda,让我们用习惯c# linq语法,也能眼前一亮。但是比起c#语法糖还是差很远。差集、并集、交集@testpublic void test1(){list list1=new arraylist<>();list1.add(1);list1.add...

    前言

    java8里最大亮点是lambda,让我们用习惯c# linq的语法,也能眼前一亮。但是比起c#的语法糖还是差的很远。

    差集、并集、交集

    @test

    public void test1(){

    list list1=new arraylist<>();

    list1.add(1);

    list1.add(2);

    list1.add(3);

    list list2=new arraylist<>();

    list2.add(3);

    list2.add(4);

    list2.add(5);

    system.out.println("====求交集===");

    list list=list1.stream().filter(t->list2.contains(t)).collect(collectors.tolist());

    list.stream().foreach(system.out::println);

    system.out.println("====求差集===");

    list=list1.stream().filter(t-> !list2.contains(t)).collect(collectors.tolist());

    list.stream().foreach(system.out::println);

    system.out.println("====求并集===");

    list.addall(list1);

    list.addall(list2);

    list=list.stream().distinct().collect(collectors.tolist());

    list.stream().foreach(system.out::println);

    }

    以上这篇java8 集合求差集、并集、交集的实例就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持萬仟网。

    希望与广大网友互动??

    点此进行留言吧!

    展开全文
  • image.png需求:用户会上送一个新集合,需要和DB中旧...上述需求可以转换为两个集合差集/交集。JDK为我们提供了对应API方法:public static void main(String[] args) {List newList = new ArrayList<>...

    a334895f92ec

    image.png

    需求:用户会上送一个新集合,需要和DB中旧集合比较。

    新集合有,旧集合没有的数据会保存。

    新集合有,旧集合有的数据会更新。

    新集合没有,旧集合有的数据会删除。

    上述需求可以转换为两个集合取 差集/交集。

    JDK为我们提供了对应的API方法:

    public static void main(String[] args) {

    List newList = new ArrayList<>();

    newList.add("A");

    newList.add("B");

    newList.add("C");

    newList.add("D");

    List oldList = new ArrayList<>();

    oldList.add("C");

    oldList.add("D");

    oldList.add("E");

    oldList.add("F");

    }

    求差集:

    //最终得到的数据是C,D(需要插入的数据)

    newList.removeAll(oldList);

    System.out.println(JSON.toJSONString(newList));

    //最终得到的数据是E,F(需要删除的数据)

    oldList.removeAll(newList);

    System.out.println(JSON.toJSONString(oldList));

    求并集:

    //最终得到的数据是C,D(需要更新的数据)

    oldList.retainAll(newList);

    System.out.println(JSON.toJSONString(oldList));

    但是在实际开发中,JDK提供的方法并不能完全的满足业务需要。

    业务场景需求:

    上送的新集合,新集合中的元素主键id必须为空才会去保存。

    新集合和旧集合只要主键id相同,那么就是一条记录,就需要去更新(若是使用ArrayList求并集的方法,那么必须重写equals方法,只要id相同那么就是true)。

    获取差集/并集后不能去修改原集合。

    //集合关系的包装类

    @Data

    public class ListRelationshipWrapper {

    //需要插入的数据

    private List insertInfos;

    //需要更新的数据

    private List updateInfos;

    //需要删除的数据

    private List deleteInfos;

    }

    public abstract class AbstractListRelationship {

    //获取到实体的主键

    protected abstract ID renderKey();

    //根据id判断是否能插入

    protected abstract boolean checkIdSave();

    //判断实体是否相等

    protected abstract boolean renderEquals(T data);

    //获取集合的关系

    public static ListRelationshipWrapper getListRelationship(List extends AbstractListRelationship> oldData,

    List extends AbstractListRelationship> newData){

    ListRelationshipWrapper wrapper = new ListRelationshipWrapper<>();

    List insertInfos =new ArrayList();

    Map newDataMap = new HashMap<>();

    //新集合(1,3)

    for(AbstractBeanDifference data : newData){

    Object o = data.renderKey();

    if(data.checkIdSave()){

    //若是能插入,保存到insertDatas集合中。

    insertDatas.add(data);

    }else{

    //以id为key,保存对象

    newDataMap.put(o,data);

    }

    }

    wrapper.setInsertDatas(insertDatas);

    List deleteDatas = new ArrayList();

    List updateDatas = new ArrayList();

    //旧集合

    for(AbstractBeanDifference data : oldData){

    //包含id,则更新

    if (newDataMap.containsKey(oldData)) {

    //两个对象不相等,才去更新

    if (!data.renderEquals(newDataMap.get(oldData)))

    updateDatas.add(newDataMap.get(oldData));

    } else {

    deleteDatas.add(newDataMap.get(oldData));

    }

    }

    wrapper.setDeleteDatas(deleteDatas);

    wrapper.setUpdateDatas(updateDatas);

    return differenceWrapper;

    }

    }

    推荐阅读

    展开全文
  • 原始对象List hrProbationMainList =new ...获取交集对象stream 转换成流 (只有变成流才能操作)filter 封装判断条件(如果true 则收集到结果中,false则不收集)collect 收集结果返回到指定类型中//交集对象Listhr...

    原始对象

    List hrProbationMainList =new ArrayList();

    List hrProbationMains = probationMainDao.findAll();

    获取交集对象

    stream 转换成流 (只有变成流才能操作)

    filter 封装判断条件(如果true 则收集到结果中,false则不收集)

    collect 收集结果返回到指定类型中

    //交集对象

    ListhrProbationMainPOS = hrProbationMainList.stream().filter(obj -> find(obj.getEmpNumber(), hrProbationMains)).collect(Collectors.toList());

    /**

    * 封装

    * @param empNumber

    * @param list

    * @return

    */

    public Boolean find(String empNumber, List list) {

    for (int i = 0; i < list.size(); i++) {

    if (list.get(i).getEmpNumber() .equals(empNumber)) {

    System.out.println(list.get(i).getEmpNumber() +"---"+empNumber+"/r/n");

    return true;

    }

    }

    return false;

    }

    获取set类型

    Set mainSet = hrProbationMains.stream().map(HrProbationMain::getEmpNumber).collect(Collectors.toSet());

    展开全文
  • public class ExtractIdUtils { public static Map<String, List<Long>> extractList(List<Long> newIds, List<Long> oldIds) { List<Long>... tempList.retainA.
    public class ExtractIdUtils {
    
    
        public static Map<String, List<Long>> extractList(List<Long> newIds, List<Long> oldIds) {
            List<Long> tempList = new ArrayList<>(oldIds);
            //取交集
            tempList.retainAll(newIds);
            //删除
            oldIds.removeAll(tempList);
            //新增
            newIds.removeAll(tempList);
            Map<String, List<Long>> extractMap = new HashMap<>();
            extractMap.put("del", oldIds);
            extractMap.put("add", newIds);
            extractMap.put("update", tempList);
    
            return extractMap;
        }
    
    
        public static void main(String[] args) {
            ArrayList<Long> newIds = new ArrayList<>();
            newIds.add(1L);
            newIds.add(2L);
            newIds.add(3L);
            newIds.add(5L);
            ArrayList<Long> oldIds = new ArrayList<>();
            oldIds.add(1L);
            oldIds.add(2L);
            oldIds.add(3L);
            oldIds.add(4L);
            Map<String, List<Long>> map = extractList(newIds, oldIds);
            List<Long> del = map.get("del");
            List<Long> add = map.get("add");
            List<Long> update = map.get("update");
    
    
            System.out.println("del………"+del);
            System.out.println("add………"+add);
            System.out.println("update………"+update);
    
        }
    }

     

    展开全文
  • Java 8 API添加了一抽象称为流Stream,可以让你以一种声明方式处理数据。Stream 使用一种类似用 SQL 语句从数据库查询数据直观方式来提供一种对 Java 集合运算和表达高阶抽象。Stream API可以极大提高...
  • 利用java8新特性 java8 lambda表达式流操作不影响原始list对象; 对象类型处理 List<Student> list1 = new ArrayList<>(); list1.add(new Student("name100","100")); list1.add(new Student(...
  • import java.util.ArrayList;import java.util.List;import static java.util.stream.Collectors.toList;/*** @author ming* @version 1.0.0* @date 2020/6/17 14:44**/public class CollectionsTest {public static...
  • 获取firstArrayList和secondArrayList交集(两个集合相同部分)、差集两个集合不同部分)以及并集(两个集合全并后数据(不包含重复数据))。测试代码如下: import java.util.Set; import java.util....
  • 调用接口获取的数据集合List list = response.getData().getItwww.cppcns.comemsnTzXmIBif();本地查询出来账户集合List towList = accountRepository.findAll();筛选差集代码List distinctB...

空空如也

空空如也

1 2 3 4 5
收藏数 82
精华内容 32
关键字:

java获取两个集合的差集

java 订阅