使用来自另一个流的值过滤流
我很难想出一个通用的方法来解决我的问题。让我们假设我有一个复杂的数据结构D。我想在D中找到满足谓词P的所有元素，它们都具有给定的过滤值F，并将结果存储在堆栈中。我为正负谓词提出了两种截然不同的解决方案。
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用于定义使用值作为筛选器实现过滤的标准。上面的例子已经被简化了，但是正确地显示了我两天来面临的问题……
有人能给我个提示吗?我怎么写这个蓝宝石来处理这两种情况？
@澄清:似乎我没有把一个重要的观点说得足够清楚，请允许我详细说明。在我给出的例子中，我有一个简单整数集合并不意味着我面临这个问题。让我们跳得更深..。
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上使用给定的转换器，并将它们映射到完全不同的东西，并在集合中返回结果，当前堆栈。
示例：
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);我没有得到无名氏，而且.部分。我拿到了所有的东西。我没有这两个谓词，我展示了消极的一个，因为这是行不通的。
回答 5
Stack Overflow用户
发布于 2017-03-03 14:57:23
的布尔补
anyMatch(s -> predicate.test(p, s))是(根据德摩根定律)
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));会给出正确的补充收集人员。
Stack Overflow用户
发布于 2017-03-03 12:16:24
您可以使用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]。
还是我错过了什么？
Stack Overflow用户
发布于 2017-03-03 12:10:14
这就是我想的你
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: truehttps://stackoverflow.com/questions/42578210
复制相似问题
腾讯云开发者
