如何使用lambda产品过滤Java8中的嵌套流

我试图根据我的

交易

选项过滤我的

交易

，但当我尝试过滤代码时，我得到一个类型不匹配错误，

设置

无法转换为布尔值。我想在所有交易选项都为红色时保留交易

这是我的密码：

import java.util.*;
import java.util.stream.Collectors;

class Deal {
    String dealname;
    String dealprice;
    Set<DealOptions> dealop;

    public String getDealname() {
        return dealname;
    }

    public void setDealname(String dealname) {
        this.dealname = dealname;
    }

    public String getDealprice() {
        return dealprice;
    }

    public void setDealprice(String dealprice) {
        this.dealprice = dealprice;
    }

    public Set<DealOptions> getDealop() {
        return dealop;
    }

    public void setDealop(Set<DealOptions> dealop) {
        this.dealop = dealop;
    }

}

class DealOptions {
    String optname;
    String color;

    public String getOptname() {
        return optname;
    }

    public void setOptname(String optname) {
        this.optname = optname;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

}

public class Test {

    public static void main(String[] args) 
             {

        Deal s = new Deal();
        Set<DealOptions> ops = new HashSet<DealOptions>();
        DealOptions op = new DealOptions();
        s.setDealname("mongo");
        s.setDealprice("500");

        op = new DealOptions();
        op.setColor("red");
        op.setOptname("redop");

        ops.add(op);
        op = new DealOptions();
        op.setColor("blue");
        op.setOptname("blueop");

        ops.add(op);
        op = new DealOptions();
        op.setColor("green");
        op.setOptname("greenop");

        ops.add(op);

        s.setDealop(ops);

        List<Deal> dl = new ArrayList<Deal>();

        dl.add(s);
        ops = new HashSet<DealOptions>();
        s = new Deal();
        op = new DealOptions();
        s.setDealname("test2");
        s.setDealprice("200");

        op = new DealOptions();
        op.setColor("indigo");
        op.setOptname("indigop");

        ops.add(op);
        op = new DealOptions();
        op.setColor("violet");
        op.setOptname("violetop");

        ops.add(op);
        op = new DealOptions();
        op.setColor("orange");
        op.setOptname("orangeop");

        ops.add(op);

        s.setDealop(ops);

        dl.add(s);

        List<Deal> dev = dl.stream().filter(
                (p) -> p.getDealop().stream().filter((po) -> po.getColor().equals("red")).collect(Collectors.toSet()))
                .collect(Collectors.toList()); // error here

    }
}

import java.util.*；
导入java.util.stream.collector；
班级交易{
字符串名称；
字符串交易价格；
设置dealop；
公共字符串getDealname（）{
返回dealname；
}
public void setDealname（字符串dealname）{
this.dealname=dealname；
}
公共字符串getDealprice（）{
退货价格；
}
公共无效setDealprice（字符串dealprice）{
this.dealprice=dealprice；
}
公共集getDealop（）{
返回解除操作；
}
公共无效SETDELAOP（SETDELAOP）{
this.dealop=dealop；
}
}
类DealOptions{
字符串optname；
字符串颜色；
公共字符串getOptname（）{
返回optname；
}
公共void setOptname（字符串optname）{
this.optname=optname；
}
公共字符串getColor（）{
返回颜色；
}
公共void setColor（字符串颜色）{
这个颜色=颜色；
}
}
公开课考试{
公共静态void main（字符串[]args）
{
交易s=新政（）；
Set ops=newhashset（）；
DealOptions op=新的DealOptions（）；
s、 setDealname（“mongo”）；
s、 设定交易价格（“500”）；
op=新的DealOptions（）；
op.setColor（“红色”）；
op.setOptname（“redop”）；
增列（op）；
op=新的DealOptions（）；
op.setColor（“蓝色”）；
op.setOptname（“blueop”）；
增列（op）；
op=新的DealOptions（）；
op.setColor（“绿色”）；
op.setOptname（“绿色op”）；
增列（op）；
s、 SETDELAOP（ops）；
List dl=new ArrayList（）；
dl.添加（s）；
ops=新的HashSet（）；
s=新政（）；
op=新的DealOptions（）；
s、 setDealname（“test2”）；
s、 设定交易价格（“200”）；
op=新的DealOptions（）；
op.setColor（“靛蓝”）；
op.setOptname（“indigop”）；
增列（op）；
op=新的DealOptions（）；
op.setColor（“紫色”）；
op.setOptname（“violetop”）；
增列（op）；
op=新的DealOptions（）；
op.setColor（“橙色”）；
op.setOptname（“orangeop”）；
增列（op）；
s、 SETDELAOP（ops）；
dl.添加（s）；
List dev=dl.stream（）.filter(
（p） ->p.getDealop（）.stream（）.filter（（po）->po.getColor（）.equals（“红色”）.collect（Collectors.toSet（））
.collect（Collectors.toList（））；//此处出错
}
}

错误：

无法从集合转换为布尔值

如何纠正此错误我如何根据我的交易选项筛选我的交易？

您可以使用来确定某个选项的所有交易是否为红色：

返回此流的所有元素是否与提供的谓词匹配

在本例中，谓词只是告诉选项是否为红色

List<Deal> output =
    dl.stream()
      .filter(d -> d.getDealop().stream().allMatch(po -> po.getColor().equals("red")))
      .collect(Collectors.toList());

列表输出=
dl.stream（）
.filter（d->d.getDealop（）.stream（）.allMatch（po->po.getColor（）.equals（“红色”））
.collect（Collectors.toList（））；

找到公共静态谓词（字符串颜色）{
返回p->p.getDealop（）.stream（）.anyMatch（op->op.getColor（）.equals（color））；
}
公共静态列表filterDeals（列表处理、谓词）{
return deals.stream（）
.filter（谓词）
.collect（Collectors.toList（））；
}
//在主方法中添加
列表dd=过滤器DEALS（dl，isFound（“红色”）；

List dd1=dl.stream（）.filter（d->d.getDealop（）.stream（）.anyMatch（p->p.getColor（）.equals（“红色”））.collect（collector.toList（））；我认为如果列表中包含任何其他颜色而不是“红色”，则该列表将返回空。原因它将返回false，因为“返回此流的所有元素是否与提供的谓词匹配。”

anyMatch

在本例中返回all。

public static Predicate<Deal> isFound(String color) {
    return p -> p.getDealop().stream().anyMatch(op->op.getColor().equals(color));
}


public static List<Deal> filterDeals (List<Deal> deals, Predicate<Deal> predicate){
        return deals.stream()
        .filter( predicate )
        .collect(Collectors.<Deal>toList());
}

//in main method add
List<Deal> dd = filterDeals(dl,isFound("red"));