Question

我很难找到解决问题的通用解决方案。假设我有一个复杂的数据结构D.我想在D中找到满足给定滤波器值F的谓词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.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写成两种情况？

@Clarification：似乎我没有把一个重要的观点弄清楚，让我详细说明。在我给出的例子中，我有一个简单整数的集合并不意味着我面临这个问题。让我们深入探讨......

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

我想找到与谓词匹配的所有SampleDataStructures。它可以是predicateA或predicateB。我不知道它会是什么，所以要用想象力。我提供了这两个，因为我的方法存在问题（请参阅我的帖子的第一部分）。然后我想在那些SampleDataStructures上使用给定的转换器并将它们映射到完全不同的东西，并将结果返回到Collection，当前是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$");

结果我想得到[简，约翰，无论约翰]

我所提供的方法存在的问题是，如果我有：

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

我没有收到[Jane Doe和......部分]。我得到每一件物品。我没有这两个谓词，我展示了否定词，因为它不起作用。

Answer 1

的布尔补码

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 2

您可以使用/[.,]+(?![ .,])/g ^^^^^

更轻松地完成此操作

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)); 还是我错过了什么？

Answer 3

这就是我的想法

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

Answer 4

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

使用其他流

4 个答案: