redList，双函数{b，listOfA-> B（B.姓名，列表A） }) } } } 但它不使用RxJava，但不使用RxJava。这样，listoflist对象将丢失。正如我在问题中所说的，过滤后的内部列表必须添加回具有正确id的正确父对象（从中获取

redList，双函数{b，listOfA-> B（B.姓名，列表A） }) } } }

---

但它不使用RxJava，但不使用RxJava。这样，listoflist对象将丢失。正如我在问题中所说的，过滤后的内部列表必须添加回具有正确id的正确父对象（从中获取内部列表的对象）。这样，listoflist对象将丢失。正如我在问题中所说，过滤后的内部列表必须添加回具有正确id的正确父对象（内部列表从中获取的对象）。

class A {
        int mAId;
        List<B> mBList;
    }

    class B{
        int mId;
    }

    public void loop(List<A> list){
        Observable.fromIterable(list)
                .flatMapIterable(objs-> objs.mBList)
                .filter("filtering each b")
                .toList()
                .map("add back the list of b to the right a")
                .subscribe()
    }

    public void loop(List<A> list){
     List<FromObject> innerList;
     list.forEach(e->{
      innerList=e.getInnerList();
      innerList.forEach(in->{
      <apply your filter here>
      <for example>
       if(in.getNumber()>0)
        innerList.remove(in);
      }
     }
    }

List<List<Integer>> listOfLists = Arrays.asList(
        Arrays.asList(0, 1, 2, 3, 4, 5),
        Arrays.asList(6, 7, 8, 9, 10, 11),
        Arrays.asList(12, 13, 14, 15, 16, 17),
        Arrays.asList(18, 19, 20, 21, 22, 23)
);

Observable.fromIterable(listOfLists)
        .flatMap((innerList) -> {
            return Observable.fromIterable(innerList)
                    .filter((value) -> value % 2 == 0)
                    .toList()
                    .toObservable();
        })
        .toList()
        .subscribe(listOfListsFiltered -> {
            for (List<Integer> innerList : listOfListsFiltered) {
                for (Integer value : innerList) {
                    System.out.print(value + ", ");
                }

                System.out.println();
            }
        });
}

public static class A {
        int id;
        List<B> mBList;
    }

    public static class B {
        int id;
    }

    public void test() {

        Observable.just(Arrays.asList(new A(), new A(), new A()))
                .flatMapIterable(a -> a)
                .map(a -> {
                    a.mBList = Observable.fromIterable(a.mBList)
                            .distinct()
                            .toList()
                            .blockingGet();
                    return a;
                });
    }

class A(val filterable: Boolean = random.nextBoolean())

class B(val name: String = random.nextInt().toString(), val listOfA: List<A> = listOf(A(), A(), A(), A(), A(), A()))

@Test
fun rxTest() {
    Observable.fromIterable(listOf(B(), B(), B(), B(), B(), B(), B()))
            .compose {
                it.publish<B> { publish ->
                    val filteredList = publish.flatMapIterable { it.listOfA }
                            .filter {
                                it.filterable
                            }
                            .toList()
                            .toObservable()
                    Observable.zip<B, List<A>, B>(publish, filteredList, BiFunction<B, List<A>, B> { b, listOfA ->
                        B(b.name, listOfA)
                    })
                }
            }
}