根据其ID删除对象，并收集已删除到另一个列表的对象

Question

我想从雇员的列表中删除（ list1 ）对象，该对象在雇员的另一个列表中不存在代码>）通过其 ID ，然后使用Java8。

示例：

List<Employee> list1 = Stream.of(
                        new Employee("100","Boston","Massachusetts"),
                        new Employee("400","Atlanta","Georgia"),
                        new Employee("300","pleasanton","California"),
                        new Employee("200","Decatur","Texas"),
                        new Employee("500","Cumming","Atlanta"),
                        new Employee("98","sula","Maine"),
                        new Employee("156","Duluth","Ohio"))
                .collect(Collectors.toList());

从上面的列表中，需要基于 ID 对象 iD 。

List<Employee> list2 = Stream.of(
                        new Employee("100","Boston","Massachusetts"),
                        new Employee("800","pleasanton","California"),
                        new Employee("400","Atlanta","Georgia"),
                        new Employee("10","Decatur","Texas"),
                        new Employee("500","Cumming","Atlanta"),
                        new Employee("50","sula","Maine"),
                        new Employee("156","Duluth","Ohio"))
                .collect(Collectors.toList());

预期输出： List1和List3

       List<Employee> list1 = Stream.of(
                        new Employee("100","Boston","Massachusetts"),
                        new Employee("400","Atlanta","Georgia"),
                        new Employee("500","Cumming","Atlanta"),
                new Employee("156","Duluth","Ohio"))
                .collect(Collectors.toList());

        List<Employee> list3 = Stream.of(
                        new Employee("300","pleasanton","California"),
                        new Employee("200","Decatur","Texas"),
                        new Employee("98","sula","Maine")
                        )
                .collect(Collectors.toList());

在下面尝试过，但无法按预期工作

        List<Employee> list3 = new ArrayList<>();
        if(CollectionUtils.isNotEmpty(list1) && CollectionUtils.isNotEmpty(list2)){
            list2.stream().forEachOrdered( l2 -> {
                Optional<Employee> nonMatch = list1.stream().filter(l1 -> !l1.getId().equalsIgnoreCase(l2.getId())).findAny();
                if(nonMatch.isPresent()){
                    list3.add(nonMatch.get());
                    list1.removeIf(l1 -> l1.getId().equalsIgnoreCase(nonMatch.get().getId()));
                }
            });
        }

        System.out.println(list1);
        System.out.println(list3);

Answer 1

这是两个可能的解决方案。

这是简短而简洁的，但实际上并没有从 List1 中删除元素，而是利用分区收集器来创建两个列表。将分区的收藏家视为一种双向过滤器：如果您的谓词满足，请收集到一个列表，如果不是，请收集到另一个列表。在我们的情况下，谓词实际上是“ List2是否包含一个与List1相同的ID的员工？”。为了降低实际开销，该代码从 list2 forront准备了ID列表。

        final List<String> list2Ids = list2.stream()
                .map(Employee::getId)
                .collect(Collectors.toList());

        Map<Boolean, List<Employee>> partitioned = list1.stream()
                .collect(Collectors.partitioningBy(e -> list2Ids.contains(e.getId())));

        list1 = partitioned.get(true);
        List<Employee> list3 = partitioned.get(false);

如果您需要保留 list1 - 例如出于内存脚印的原因 - 并且确实必须从中删除元素，我会说您必须坚持使用真正的老式迭代器。这样做的原因是迭代器允许您在此过程中迭代某些集合和删除元素。下一个样本完全做到这一点。请注意，我再次准备了 list2 的ID列表。

        final List<String> list2Ids = list2.stream()
                .map(Employee::getId)
                .collect(Collectors.toList());

        final List<Employee> list3 = new LinkedList<>();

        for (Iterator<Employee> iterator = list1.iterator(); iterator.hasNext();) {
            Employee next = iterator.next();

            if (!list2Ids.contains(next.getId())) {
                list3.add(next);
                iterator.remove();
            }
        }

Answer 2

当前代码的问题：

• 记住是经验法则：每次您发现自己使用 foreach 在流外更改某些东西时，很可能出现了问题（*请看一下 api文档 。 循环的普通没有任何优势。
• > foreach（）对 /wiki/self-documenting_code“ rel =“ nofollow noreferrer”> 自我解释的名称 。喜欢 empldeparmentx ， empleolddb 等名称 list1 更难

在代码上解决此问题（ 时间复杂性）：

• 创建 ID>的 id 的 中包含的 list2 （剩余：包含的时间复杂性检查是 o（1））;
• 从 employee 的列表中生成 list1 中没有常见 ID> ID 的 noncommonid 中的） 雇员在 list2 中包含在 list1 的每个 id 中， set set 在上一步获得。
• 从列表中删除具有不同 ID 的员工会单独导致额外的性能开销，因为每个删除都有线性时间的复杂性。一个更好的选择是使用 removeAll（）。
• 在列表上应用 removeAll（） id 丢弃了上一步中获得的列表中存在的所有员工。

总体时间复杂性 o（n + m）（ n 和 m - 是 list1 中的元素数字和 list2 ）。

Set<String> idSet = list2.stream()
    .map(Employee::id)
    .collect(Collectors.toSet());
            
List<Employee> nonCommonId = list1.stream()
    .filter(emp ->  !idSet.contains(emp.id()))
    .collect(Collectors.toList());
            
list1.removeAll(new HashSet<>(nonCommonId)); // list `nonCommonId` is wrapped by the HashSet to improve performance, because `removeAll()` relies on the `contains()` checks
// diplaying results
System.out.println("List1:");
list1.forEach(System.out::println);
            
System.out.println("nonCommonId:");
nonCommonId.forEach(System.out::println);

输出：

List1:
Employee[id=100, city=Boston, state=Massachusetts]
Employee[id=400, city=Atlanta, state=Georgia]
Employee[id=500, city=Cumming, state=Atlanta]
Employee[id=156, city=Duluth, state=Ohio]
nonCommonId:
Employee[id=300, city=pleasanton, state=California]
Employee[id=200, city=Decatur, state=Texas]
Employee[id=98, city=sula, state=Maine]

链接到在线演示

Answer 3

首先从List2获取不同的ID列表2

idList = list2.stream().map(Employee::getID).distinct().collect(Collectors.toList())

删除具有从list1的通用ID的员工并获取List3。

ArrayList<Employee> list3 =  list1.stream().filter(e->!idList .contains(e.getID())).collect(Collectors.toList());


list1 = list1.stream().filter(e->idList.contains(e.getID())).collect(Collectors.toList());