Question

我有一个对象A列表，在每个A中我都有一个对象B列表。

这就是我想要做的事情：

在使用RxJava循环List<A>时我希望能够循环内部列表并对List<B>进行一些过滤，最后，我想添加过滤的{{1} } {到List<B>的原始父对象。

这种操作是否可以在不破坏链的情况下进行？

类似这样的例子：

List<A>

Answer 1

我的意见：

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

希望它会有所帮助

Answer 2

是的，你可以通过嵌套反应流来实现它：

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

Answer 3

为未来的读者或更好的答案的灵感。有另一种方法可以做到这一点

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

Answer 4

我终于找到了解决这个问题的方法：

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

循环嵌套列表RxJava2

4 个答案: