如何在Java8中过滤出嵌套列表 package com.example.java； 导入java.util.List； 公共B级{ 清单c； 公共列表getListC（）{ 返回listC； } 公共无效集合列表B（列表列表C）{ this.listC=listC； } @凌驾 公共字符串toString（）{ 返回“B[listC=“+listC+”]”； } } package com.example.java； 导入java.util.List； 公共A类{ 名单b； 公共列表getListB（）{ 返回列表b； } 公共无效集合列表B（列表列表B）{ this.listB=listB； } @凌驾 公共字符串toString（）{ 返回“A[listB=“+listB+”]”； } }

我有一个类对象的列表，想过滤掉C，其中名称是“C1”

---

A-->B列表-->C列表（如果C.getName（）.equals（“C1”）则过滤掉）

假设您要修改现有列表，而不是创建新的列表实例：

package com.example.java;

import java.util.List;

public class A {

    List<B> listB;

    public List<B> getListB() {
        return listB;
    }

    public void setListB(List<B> listB) {
        this.listB = listB;
    }

    @Override
    public String toString() {
        return "A [listB=" + listB + "]";
    }
}

---

您可以使用streams非常轻松地完成这项工作，您只需执行

flatMap

并对内部列表进行流式处理，最后获取

流

。然后，您可以继续使用name属性过滤该流

A a = ...
a.getListB().forEach(b -> {
    b.setListB(b.getListC().stream()
     .filter(c -> !c.getName().equals("C1"))
     .collect(Collectors.toList()));
});

var someList=List.of（new A（），new A（））；
var filtered=someList
.stream（）
.flatMap（a->a.getListB（）.stream（））
.flatMap（b->b.getListC（）.stream（））
.filter（（（谓词如果只涉及C的对象，则可以使用以下选项：

var someList = List.of(new A(), new A());
var filtered = someList
        .stream()
        .flatMap(a -> a.getListB().stream())
        .flatMap(b -> b.getListC().stream())
        .filter(((Predicate<? super C>) c -> c.getName().equals("something")).negate())
        .collect(Collectors.toList());

您还可以使用使其更具可读性。
A a0=new A（）；
 list.stream().forEach( a -> {
            a.getListB().stream().forEach( b -> {
                b.getListC().stream().filter(c -> c.getName().equals("C1")).forEach( c-> {
                    // Write your code.
                });
            } );
        });

a1=新的A（）；
List sourceList=Arrays.asList（a0，a1）；
B b0=新的B（）；
B b1=新的B（）；
b2=新的B（）；
b3=新的B（）；
C c0=新的C（）；
C c1=新的C（）；
C c2=新的C（）；
c3=新的C（）；
c0.name=“ciao”；
c1.name=“c1”；
c2.name=“你好”；
c3.name=“C1”；
listC=newarraylist（）{{add（c0）；add（c1）；}；
b1.listC=newarraylist（）{{add（c2）；add（c3）；}；
a0.listB=newarraylist（）{{add（b0）；add（b1）；}；
a1.listB=newarraylist（）{{add（b2）；add（b3）；}；
//包含C1的所有A
List ALLACONTAINSC1对象=源列表
.stream（）.filter（a->Optional.ofNullable（a.getListB（））.OrelGet（（）->new ArrayList（））.stream（）
.filter（b->Optional.ofNullable（b.getListC（））.OrelGet（（）->new ArrayList（））.stream（）
.filter（c->（（c）c.getName（）.equals（“C1”））.count（）>0）
.count（）>0.collect（collector.toList（））；
//所有C对象C1
List allCObjectMatchedC1=sourceList.stream（）.filter（a->Optional.ofNullable（a.getListB（））.isPresent（））
.flatMap（a->a.getListB（）.stream（））
.filter（b->Optional.ofNullable（b.getListC（））.isPresent（））
.flatMap（b->b.listC.stream（））
.filter（c->Optional.ofNullable（c.getName（））.isPresent（）和&c.name.equals（“C1”））
.collect（Collectors.toList（））；
//所有对象都只包含C1
最终列表AllAObjectWithC1Only=sourceList
.stream（）
.filter（a->Optional.ofNullable（a.getListB（））.orelsGet（（）->
新建ArrayList（））.stream（）
.过滤器（b->可选
.ofNullable（b.getListC（））.isPresent（））
.peek（b->{
迭代器i=b.getListC（）.Iterator（）；
while（i.hasNext（））
{if（i.next（）.getName（）.equals（“C1”）==false）
{i.remove（）；}}
}）.count（）>0.collect（collector.toList（））；
在您的代码中没有一个
列表。但即使假设有一个列表，您的问题仍然不清楚，因为我们不知道您想从哪个列表中“过滤掉C，其中名称为“C1”。那么，您是只想忽略所有
列表中的
C
，还是想忽略每个
B
，哪个列表包含任何/所有具有指定名称的C元素？或者其他什么？不是基于java 8的答案。此外，您正在删除元素，修改列表的内容。我认为这不是OP所要求的。@Ar是的，我只是在写流版本。避免在谓词中使用反向检查。最好是否定谓词以提高可读性。你建议如何使用流删除与某些条件匹配的项？我认为OP希望保留列表，而不是获取所有与该条件匹配的C元素。虽然这也是对这个问题的合理解释。此外，OP想过滤掉名称等于某物的
C
。您保留了匹配元素。谢谢您的回答。但我需要一个列表，所以我不能使用flatMap。好的，对不起，我更改了代码，读到“想过滤掉名称为“C1”的C”。希望能有所帮助。C1=新C（）cC2=new C（）；cC3=new C（）；c1.setName（“c1”）；c2.setName（“c2”）；c3.setName（“c3”）；b1=new B（）；b2=new B（）；a1=new A（）；a2=new A（）；List lc=new ArrayList（）；lc.add（c1）；lc.add（c2）；List lc2=new ArrayList（）；lc2.add（c3）；List lb=new ArrayList（）；b1.setListB（lc）；lb.add（b1）；List lb2=new ArrayList（）；b2.setListB（lc2）；lb2.add（b2）；List la=new ArrayList（）；a1.setListB（lb）；a2.setListB（lb2）；la.add（a1）；la.add（a2）；[A[listB=[B[C[name=C1]，C[name=C2][][C2][C2][C1][C1][C2][C1][C1]但我期望的输出是[A[listB C=]
A a = ...
a.getListB().forEach(b -> {
    b.setListB(b.getListC().stream()
     .filter(c -> !c.getName().equals("C1"))
     .collect(Collectors.toList()));
});

var someList = List.of(new A(), new A());
var filtered = someList
        .stream()
        .flatMap(a -> a.getListB().stream())
        .flatMap(b -> b.getListC().stream())
        .filter(((Predicate<? super C>) c -> c.getName().equals("something")).negate())
        .collect(Collectors.toList());

 list.stream().forEach( a -> {
            a.getListB().stream().forEach( b -> {
                b.getListC().stream().filter(c -> c.getName().equals("C1")).forEach( c-> {
                    // Write your code.
                });
            } );
        });

        A a0=new A();
        A a1=new A();

        List<A> sourceList = Arrays.asList(a0, a1);

        B b0= new B();
        B b1= new B();
        B b2= new B();
        B b3= new B();

        C c0=new C();
        C c1=new C();
        C c2=new C();
        C c3=new C();

        c0.name="ciao";
        c1.name="C1";
        c2.name="hello";
        c3.name="C1";


        b0.listC=new ArrayList(){{add(c0); add(c1);}};
        b1.listC=new ArrayList(){{add(c2); add(c3);}};

        a0.listB=new ArrayList(){{add(b0); add(b1);}};
        a1.listB=new ArrayList(){{add(b2); add(b3);}};


          //ALL A THAT CONTAINS C1    
    List<A> allAContainsC1Objects =  sourceList
            .stream().filter( a-> Optional.ofNullable(a.getListB()).orElseGet(()-> new ArrayList<>()).stream()
                    .filter(b->Optional.ofNullable(b.getListC()).orElseGet(()-> new ArrayList()).stream()
                            .filter(c-> ((C)c).getName().equals("C1")).count()>0)
                    .count()>0).collect(Collectors.toList());


    //ALL C OBJECT C1
    List<C> allCObjectMatchedC1 = sourceList.stream().filter(a -> Optional.ofNullable(a.getListB()).isPresent())
            .flatMap(a -> a.getListB().stream())
            .filter(b -> Optional.ofNullable(b.getListC()).isPresent())
            .flatMap(b -> b.listC.stream())
            .filter(c-> Optional.ofNullable(c.getName()).isPresent()&&c.name.equals("C1"))
            .collect(Collectors.toList());

  //ALL A OBJECT WITH C1 only  
  final  List<A>  AllAObjectWithC1Only=  sourceList
          .stream()
          .filter( a-> Optional.ofNullable(a.getListB()).orElseGet(()-> 
          new ArrayList<>()).stream()
                  .filter(b->Optional
                  .ofNullable(b.getListC()).isPresent())
                  .peek(b-> {
                      Iterator<C> i = b.getListC().iterator();
                      while (i.hasNext()) 
                   {if(i.next().getName().equals("C1")==false) 
                  {i.remove();}}
                  } ).count()>0).collect(Collectors.toList());