java - 使用来自另一个流的值过滤流

Question

我很难想出一个通用的解决方案来解决我的问题。假设我有一个复杂的数据结构 D。我想在 D 中找到所有满足具有给定过滤器值 F 的谓词 P 的元素，并将结果存储在 Stack 中。我针对正谓词和负谓词提出了两种截然不同的解决方案。

List<Integer> sample = Arrays.asList(0,1,2,3,4,5,6,7,8,9);
List<String> values = Arrays.asList("4","5","6");

BiPredicate<Integer, String> predicate = (d,f) -> d.equals(Integer.valueOf(f));
Function<Integer, Integer> converter = Function.identity();

Collection<Integer> filtered = sample.parallelStream()
                                     .filter(d -> values.parallelStream()
                                                        .anyMatch(f -> predicate.test(d, f)))
                                     .map(converter::apply)
                                     .collect(Collectors.toCollection(Stack::new));

问题:只要我的谓词是否定的，上述方法就有效。在大写情况下，结果是 [4, 5, 6]。但是，如果我将谓词更改为 !d.equals(Integer.valueOf(f)) 结果变为 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ].为了解决否定谓词，我必须将过滤器更改为:

.filter(d -> values.parallelStream()
                   .distinct()
                   .allMatch(f -> predicate.test(d, f))

但这样做会破坏正谓词。问题有点复杂，因为样本包含具有多个不同类型属性的对象。 BiPredicate 用于定义满足使用值作为过滤器的过滤的条件。上面的例子刚刚被简化，但正确地显示了我现在面临 2 天的问题......

任何人都可以告诉我如何编写这个 lambda 来处理这两种情况？

@澄清:似乎我未能足够清楚地说明一个要点，请允许我详细说明。在我给出的例子中，我有一个简单整数的集合并不意味着我正面临这个问题。让我们深入探讨...

class SampleDataStructure {
    PropertyType_0 property_0;
    PropertyType_1 property_1;
    ...
    PropertyType_N property_n;

    // getters defined.
}

Collection<SampleDataStructure> sample = ...; // Let's assume it has been initialized.

现在，让我们获取 SampleDataStructure 的任意属性 (PropertyType_I property_i)。这将是过滤我的 Collection 的关键。我有另一个 PropertyType_I 类型的集合:

Collection<PropertyType_I> values = ...; //A set of values that will be used by the predicate.

为了简单起见，我还有一个谓词:

BiPredicate<SampleDataStructure, PropertyType_I> predicateA = (data, value) -> data.getPropertyI().equals(value);
BiPredicate<SampleDataStructure, PropertyType_I> predicateB = (data, value) -> !data.getPropertyI().equals(value);

我想找到与谓词匹配的所有 SampleDataStructures。它可以是 predicateA 或 predicateB。我不知道它会是什么，所以请发挥想象力。我提供这两个是因为我的方法存在问题(请参阅我的帖子的第一部分)。然后我想在这些 SampleDataStructures 上使用给定的转换器并将它们映射到完全不同的东西并将结果返回到一个集合中，当前是 Stack。

例子:

sample = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
values = [4, 5, 6]

Predicate_1 = (s, v) -> s == v       Result = [4, 5, 6]
Predicate_2 = (s, v) -> s != v       Result = [0, 1, 2, 3, 7, 8, 9]

values = []

Predicate_1 = (s, v) -> s == v       Result = []
Predicate_2 = (s, v) -> s != v       Result = []

values = [99]

Predicate_1 = (s, v) -> s == v       Result = []
Predicate_2 = (s, v) -> s != v       Result = []

所有这些都意味着那些假设样本或值只是简单类型的建议解决方案是错误的。它们都可以是任意复杂的数据结构，并且 BiPredicate 告诉应该如何根据值过滤样本数据。我希望一切都清楚。

这是另一个例子:

class Person {
    private long id;
    String name;
    public Person(long id, String name) { this.id = id; this.name = name; }
    public long getId() { return id; }
    public Strin getName() { return name; }
}

Collection<Person> persons = Arrays.asList(new Person(1, "Jane"), new Person(2, "Doe"), new Person(3, "Jane Doe"), new Person(4, "John"), new Person(5, "whatever John"), ...);
BiPredicate<Person, String> predicate = (p, f) -> p.getName().matches(f);
Function<Person, String> personToName = Person::getName;
List<String> selectors = Arrays.asList("^Jane$", "John$");

结果我想得到 [Jane, John, whatever John]

但是我提供的方法的问题是如果我有:

BiPredicate<Person, String> predicate = (p, f) -> !p.getName().matches(f);

我没有得到 [Jane Doe 和 ... 部分]。我得到每一个项目。我没有两个谓词，我显示了否定的谓词，因为那不起作用。

Answer 1

的 boolean 补数

anyMatch(s -> predicate.test(p, s))

是(根据 De Morgan's laws )

allMatch(s -> !predicate.test(p, s))

但不是(正如您在帖子中所想的那样)

anyMatch(s -> !predicate.test(p, s))

适用于您的情况:

Collection<Person> filtered = persons
            .parallelStream()
            .filter(p -> selectors.parallelStream().anyMatch(s -> predicate.test(p, s)))
            .collect(Collectors.toCollection(Stack::new));

将给出一个 Persons 集合。和

Collection<Person> filtered = persons
            .parallelStream()
            .filter(p -> selectors.parallelStream().allMatch(s -> !predicate.test(p, s)))
            .collect(Collectors.toCollection(Stack::new));

将给出正确的 Persons 补充集合。