Java 8 lambda 从列表中获取和删除元素

Question

给定一个元素列表，我想获取具有给定属性的元素并将其从列表中删除。 我找到的最佳解决方案是：

ProducerDTO p = producersProcedureActive
                .stream()
                .filter(producer -> producer.getPod().equals(pod))
                .findFirst()
                .get();
producersProcedureActive.remove(p);

是否可以在 lambda 表达式中结合 get 和 remove ？

Answer 1

从列表中删除元素

objectA.removeIf(x -> conditions);

例如：

objectA.removeIf(x -> blockedWorkerIds.contains(x));

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

str1.removeIf(x -> str2.contains(x)); 

str1.forEach(System.out::println);

输出： ABC

Answer 2

虽然线程很老，但仍然认为提供解决方案 - 使用Java8 。

使用removeIf函数。 时间复杂度为O(n)

producersProcedureActive.removeIf(producer -> producer.getPod().equals(pod));

API 参考： removeIf 文档

假设： producersProcedureActive是一个List

注意：使用这种方法，您将无法保留已删除的项目。

Answer 3

考虑使用 vanilla java 迭代器来执行任务：

public static <T> T findAndRemoveFirst(Iterable<? extends T> collection, Predicate<? super T> test) {
    T value = null;
    for (Iterator<? extends T> it = collection.iterator(); it.hasNext();)
        if (test.test(value = it.next())) {
            it.remove();
            return value;
        }
    return null;
}

优点：

1. 这是显而易见的。
2. 它只遍历一次，并且只遍历到匹配的元素。
3. 即使没有stream()支持，您也可以在任何Iterable上执行此操作（至少那些在其迭代器上实现remove()的） 。

缺点：

1. 您不能将其作为单个表达式执行（需要辅助方法或变量）

---

至于

是否可以在 lambda 表达式中结合 get 和 remove ？

其他答案清楚地表明这是可能的，但您应该注意

1. 搜索和删除可能会遍历列表两次
2. 从正在迭代的列表中删除元素时可能会引发ConcurrentModificationException

Answer 4

直接的解决方案是在findFirst()返回的 Optional 上调用ifPresent(consumer) ) 。 当可选项不为空时，将调用此使用者。 好处还在于，如果 find 操作返回一个空的可选项，它不会抛出异常，就像您当前的代码一样； 相反，什么都不会发生。

如果要返回删除的值，可以将Optional map到调用remove的结果：

producersProcedureActive.stream()
                        .filter(producer -> producer.getPod().equals(pod))
                        .findFirst()
                        .map(p -> {
                            producersProcedureActive.remove(p);
                            return p;
                        });

但请注意， remove(Object)操作将再次遍历列表以查找要删除的元素。 如果您有一个随机访问的列表，例如ArrayList ，最好在列表的索引上创建一个 Stream 并找到与谓词匹配的第一个索引：

IntStream.range(0, producersProcedureActive.size())
         .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))
         .boxed()
         .findFirst()
         .map(i -> producersProcedureActive.remove((int) i));

使用此解决方案， remove(int)操作直接对索引进行操作。

Answer 5

使用可以使用 Java 8 的过滤器，如果您不想更改旧列表，请创建另一个列表：

List<ProducerDTO> result = producersProcedureActive
                            .stream()
                            .filter(producer -> producer.getPod().equals(pod))
                            .collect(Collectors.toList());

Answer 6

我敢肯定这将是一个不受欢迎的答案，但它有效......

ProducerDTO[] p = new ProducerDTO[1];
producersProcedureActive
            .stream()
            .filter(producer -> producer.getPod().equals(pod))
            .findFirst()
            .ifPresent(producer -> {producersProcedureActive.remove(producer); p[0] = producer;}

p[0]将保存找到的元素或为空。

这里的“技巧”是通过使用有效最终的数组引用来规避“有效最终”问题，但设置其第一个元素。

Answer 7

使用Eclipse Collections ，您可以在任何 java.util.List 上使用detectIndex和remove(int) 。

List<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int index = Iterate.detectIndex(integers, i -> i > 2);
if (index > -1) {
    integers.remove(index);
}

Assert.assertEquals(Lists.mutable.with(1, 2, 4, 5), integers);

如果使用 Eclipse Collections 中的MutableList类型，则可以直接在列表上调用detectIndex方法。

MutableList<Integer> integers = Lists.mutable.with(1, 2, 3, 4, 5);
int index = integers.detectIndex(i -> i > 2);
if (index > -1) {
    integers.remove(index);
}

Assert.assertEquals(Lists.mutable.with(1, 2, 4, 5), integers);

注意：我是 Eclipse Collections 的提交者

Answer 8

下面的逻辑是不修改原始列表的解决方案

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

List<String> str3 = str1.stream()
                        .filter(item -> !str2.contains(item))
                        .collect(Collectors.toList());

str1 // ["A", "B", "C", "D"]
str2 // ["D", "E"]
str3 // ["A", "B", "C"]

Answer 9

当我们想将List 中的多个元素放入新列表（使用谓词过滤）并将它们从现有列表中删除时，我无法在任何地方找到正确的答案。

下面是我们如何使用 Java Streaming API 分区来做到这一点。

Map<Boolean, List<ProducerDTO>> classifiedElements = producersProcedureActive
    .stream()
    .collect(Collectors.partitioningBy(producer -> producer.getPod().equals(pod)));

// get two new lists 
List<ProducerDTO> matching = classifiedElements.get(true);
List<ProducerDTO> nonMatching = classifiedElements.get(false);

// OR get non-matching elements to the existing list
producersProcedureActive = classifiedElements.get(false);

通过这种方式，您可以有效地从原始列表中删除过滤后的元素并将它们添加到新列表中。

参见5.2。 本文的Collectors.partitioningBy部分。

Answer 10

正如其他人所建议的那样，这可能是循环和可迭代的用例。 在我看来，这是最简单的方法。 如果您想就地修改列表，无论如何都不能将其视为“真正的”函数式编程。 但是您可以使用Collectors.partitioningBy()来获得一个包含满足您条件的元素的新列表，以及一个不满足您条件的新列表。 当然，使用这种方法，如果您有多个满足条件的元素，那么所有这些都将在该列表中，而不仅仅是第一个。

Answer 11

resumoRemessaPorInstrucoes.removeIf(item -> 
            item.getTipoOcorrenciaRegistro() == TipoOcorrenciaRegistroRemessa.PEDIDO_PROTESTO.getNome() ||
            item.getTipoOcorrenciaRegistro() == TipoOcorrenciaRegistroRemessa.SUSTAR_PROTESTO_BAIXAR_TITULO.getNome());

Answer 12

结合我最初的想法和您的回答，我得出了似乎是我自己问题的解决方案：

public ProducerDTO findAndRemove(String pod) {
    ProducerDTO p = null;
    try {
        p = IntStream.range(0, producersProcedureActive.size())
             .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))
             .boxed()
             .findFirst()
             .map(i -> producersProcedureActive.remove((int)i))
             .get();
        logger.debug(p);
    } catch (NoSuchElementException e) {
        logger.error("No producer found with POD [" + pod + "]");
    }
    return p;
}

它允许使用不再次遍历列表的remove(int)删除对象（如@Tunaki 所建议的那样） ，它允许将删除的对象返回给函数调用者。

我阅读了您的答案，建议我选择ifPresent而不是get之类的安全方法，但我找不到在这种情况下使用它们的方法。

这种解决方案有什么重要的缺点吗？

按照@Holger 的建议进行编辑

这应该是我需要的功能

public ProducerDTO findAndRemove(String pod) {
    return IntStream.range(0, producersProcedureActive.size())
            .filter(i -> producersProcedureActive.get(i).getPod().equals(pod))      
            .boxed()                                                                
            .findFirst()
            .map(i -> producersProcedureActive.remove((int)i))
            .orElseGet(() -> {
                logger.error("No producer found with POD [" + pod + "]"); 
                return null; 
            });
}

Answer 13

任务是：从列表中获取✶和✶删除元素

p.stream().collect( Collectors.collectingAndThen( Collector.of(
    ArrayDeque::new,
    (a, producer) -> {
      if( producer.getPod().equals( pod ) )
        a.addLast( producer );
    },
    (a1, a2) -> {
      return( a1 );
    },
    rslt -> rslt.pollFirst()
  ),
  (e) -> {
    if( e != null )
      p.remove( e );  // remove
    return( e );    // get
  } ) );

Answer 14

上述变体：

    import static java.util.function.Predicate.not;

    final Optional<MyItem> myItem = originalCollection.stream().filter(myPredicate(someInfo)).findFirst();
    final List<MyItem> myOtherItems = originalCollection.stream().filter(not(myPredicate(someInfo))).toList();

    private Predicate<MyItem> myPredicate(Object someInfo) {
        return myItem -> myItem.someField() == someInfo;
    }