使用流元素之间的相关性过滤流

Question

假设有一个 Person 类如下所示：

public class Person {
    private int id;
    private String discriminator;
    // some other fields plus getters/setters
}

现在我有一个< code>Person元素的< code>Stream，该流可能包含多个< code>Person实例，这些实例具有相同的< code>id，但具有不同的< code>discriminator值，即< code>[Person{"id": 1，" discriminator": "A"}，Person{"id": 1，" discriminator": "B"}，Person{"id": 2，" discriminator": "A"}，...]

我想做的是，如果至少有一个具有某个id的Person实例具有特定的鉴别器值，则过滤掉具有该id的所有Person。因此，继续上面的示例，按鉴别器值“A”过滤将生成空集合（当然，在缩减操作之后），按鉴别符值“B”过滤将产生不包含任何id等于1的Person实例的集合。

我知道我可以使用groupingBy收集器和分组元素来减少流，Person.id 然后如果映射的列表包含具有指定鉴别器值的Person元素，则从生成的Map中删除映射，但我仍然想知道是否有更简单的方法来实现相同的结果？

Answer 1

下面我将介绍我提出的解决方案。首先，我按人员对输入人员集合/流进行分组。id属性，然后我对映射条目进行流式处理，并过滤掉至少有一个值与给定鉴别器匹配的条目。

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

public class Main {

    public static void main(String[] args) {
        List<Person> persons = Arrays.asList(
            new Person(1, "A"),
            new Person(1, "B"),
            new Person(1, "C"),
            new Person(2, "B"),
            new Person(2, "C"),
            new Person(3, "A"),
            new Person(3, "C"),
            new Person(4, "B")
        );

        System.out.println(persons);
        System.out.println(filterByDiscriminator(persons, "A"));
        System.out.println(filterByDiscriminator(persons, "B"));
        System.out.println(filterByDiscriminator(persons, "C"));
    }

    private static List<Person> filterByDiscriminator(List<Person> input, String discriminator) {
        return input.stream()
            .collect(Collectors.groupingBy(Person::getId))
            .entrySet().stream()
            .filter(entry -> entry.getValue().stream().noneMatch(person -> person.getDiscriminator().equals(discriminator)))
            .flatMap(entry -> entry.getValue().stream())
            .collect(Collectors.toList());
    }

}

class Person {

    private final Integer id;
    private final String discriminator;

    public Person(Integer id, String discriminator) {
        Objects.requireNonNull(id);
        Objects.requireNonNull(discriminator);
        this.id = id;
        this.discriminator = discriminator;
    }

    public Integer getId() {
        return id;
    }

    public String getDiscriminator() {
        return discriminator;
    }

    @Override
    public String toString() {
        return String.format("%s{\"id\": %d, \"discriminator\": \"%s\"}", getClass().getSimpleName(), id, discriminator);
    }
}

Answer 2

尤金的答案很好，但我个人更喜欢单一的语句。所以我把他的代码放在一起，放入一个操作中。看起来像这样：

final List<Person> result = persons.stream()
    .filter(p -> "B".equalsIgnoreCase(p.getDiscriminator()))
    .map(Person::getId)
    .collect(
        () -> new ArrayList<>(persons),
        ( list, id ) -> list.removeIf(p -> p.getId() == id),
        ( a, b ) -> {throw new UnsupportedOperationException();}
    );

可能需要提到需要人的副本，否则Stream将损坏并遇到null值。

旁注：此版本在尝试并行使用时，当前会引发不受支持的操作异常。

Answer 3

如果我正确地理解了您的问题，您将首先找到与鉴别器匹配的所有ID：

Set<Integer> ids = persons.stream()
       .filter(p -> "A".equalsIgnoreCase(p.getDiscriminator()))
       .map(Person::getId)
       .collect(Collectors.toSet())

然后删除与以下内容匹配的条目：

persons.removeIf(x -> ids.contains(x.getId()))