使用另一个流中的值筛选java流

Question

我很难想出一个通用的解决方案来解决我的问题。假设我有一个复杂的数据结构D，我想在D中找到满足谓词P的所有元素，并将结果存储在堆栈中。 我提出了两种不同的方法来解决正谓词和负谓词

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、 等于（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用于定义满足筛选条件（使用值作为筛选条件）。上面的例子刚刚被简化，但正确地显示了我现在面临的两天问题

任何人都可以给我一个提示，我如何写这个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）。这将是筛选我收藏的关键。我还有另一个类型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);

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

例如：

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$");

因此我想得到[简，约翰，随便什么约翰]

然而，我提供的方法的问题在于：

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

我不明白[简·多伊和…部分]。我买了所有的东西。我没有两个谓词，我显示了否定的一个，因为这不起作用

Answer 1

关于answer of Thomas Fritsch，只需更改Predicate就可以在一行中完成。你不再需要BiPredicate

Predicate<Integer> predicate = (f) -> !values.contains(String.valueOf(f));
Predicate<Integer> predicatePositive = (f) -> values.contains(String.valueOf(f));
Function<Integer, Integer> converter = Function.identity();

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

Answer 2

的布尔补

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));

将提供一组人员。及

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

将提供正确的人员补充集合

Answer 3

使用List.contains可以更轻松地做到这一点：

Collection<Integer> filtered = sample.parallelStream()
                                     .filter(f -> values.contains(String.valueOf(f)))
                                     .collect(Collectors.toCollection(Stack::new));

给出结果[4, 5, 6]。及

Collection<Integer> filtered = sample.parallelStream()
                                     .filter(f -> !values.contains(String.valueOf(f)))
                                     .collect(Collectors.toCollection(Stack::new));

给出结果[0, 1, 2, 3, 7, 8, 9]
还是我错过了什么

Answer 4

这就是我所想的

public static void main(String[] args) {
    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) -> {
        return d.equals(Integer.valueOf(f));
    };

    Function<Integer, Integer> converter = Function.identity();

    Map<Integer, Boolean> filtered =
            sample.parallelStream()
                    .collect(Collectors.toMap(intVal -> converter.apply(intVal), intVal -> values.parallelStream().noneMatch(stringVal -> predicate.test(intVal, stringVal))));

    System.out.println("filtered:");
    filtered.forEach((k,v) -> {
        System.out.println("positive:" + k + " val: " + v);
    });

}

结果：

positive:0 val: true
positive:1 val: true
positive:2 val: true
positive:3 val: true
positive:4 val: false
positive:5 val: false
positive:6 val: false
positive:7 val: true
positive:8 val: true
positive:9 val: true