如何从列表中收集所有整数<；单个<；列表<；Int>&燃气轮机&燃气轮机；并将其放入列表中<；Int>；在RxJava中？

我的目标是打开一个整数列表的单子列表，并获取它的所有元素，以便将其放入列表中

List<Single<List<Int>>> listOfSinglesOfListofInts = getListSingleListType(); // random method that gives us that.
List<Int> intList = new ArrayList<>();

listInt的大小始终为0

---

完成此操作的正确方法是什么？

map

操作在

可流动链完成之前不会运行。此可流动的
已设置，但未执行。您可能要做的是在展平形状后，通过块收集器运行
可流动
。试试这个：

return Flowable.fromIterable(listOfSingleOfListofInt)
    .flatMap(singleOfListofInt -> singleOfListofInt.toFlowable())
    .flatMap(listofInt -> Flowable.fromIterable(listofInt))
    .toList()
    .blockingGet();

细节
Flowable.fromIterable（ListofSingleOfListFint）
：


将
列表
转换为
可流动

flatMap（SingleOfListFint->SingleOfListFint.toFlowable（））
：


将
可流动
转换为
可流动

flatMap（listofInt->Flowable.fromIterable（listofInt））
：


将
可流动
转换为
可流动

toList（）
：


将
可流动
转换为
单一

blockingGet（）


将
符号
转换为
列表
我是用Rx Java做的

Lets consider below example to create List<Single<List<Integer>>> 

List<Integer> intList = new ArrayList<>();
Collections.addAll(intList, 10, 20, 30, 40, 50);

List<Integer> intList2 = new ArrayList<>();
Collections.addAll(intList2, 12, 22, 32, 42, 52);

List<Integer> intList3 = new ArrayList<>();
Collections.addAll(intList3, 13, 23, 33, 43, 53);

Single<List<Integer>> singleList = Single.just(intList);
Single<List<Integer>> singleList2 = Single.just(intList2);
Single<List<Integer>> singleList3 = Single.just(intList3);

List<Single<List<Integer>>> listOfSinglesOfListofInts = new ArrayList<>();

Collections.addAll(listOfSinglesOfListofInts, singleList, singleList2, singleList3);


Observable
    //Iterate through List<Singles>
    .fromIterable(listOfSinglesOfListofInts)
    //Get each single, convert to Observable and iterate to get all the integers
    .flatMap(
        singleListNew -> singleListNew
            .toObservable()
            //Iterate through each integer inside a list and return it
            .flatMapIterable(integers -> integers)
    )
    //Get all the integers from above and convert to one list
    .toList()
    //Result is List<Integer>
    .subscribe(
        result -> System.out.println("**** " + result.toString() + " ****"),
        error -> new Throwable(error)
    );

<代码>让我们考虑下面的示例来创建列表
List intList=new ArrayList（）；
集合.addAll（intList，10,20,30,40,50）；
List intList2=new ArrayList（）；
集合。addAll（intList2、12、22、32、42、52）；
List intList3=新的ArrayList（）；
集合。addAll（intList3、13、23、33、43、53）；
Single-singleList=Single.just（intList）；
Single singleList2=Single.just（intList2）；
Single singleList3=Single.just（intList3）；
List ListOfSingleSofListFints=new ArrayList（）；
addAll（ListofSinglesOfListFints、singleList、singleList2、singleList3）；
可观察
//遍历列表
.fromIterable（单根列表）
//获取每一个，转换为可观察的，然后迭代得到所有整数
.平面图(
singleListNew->singleListNew
.TooObservable（）文件
//遍历列表中的每个整数并返回它
.flatMapIterable（整数->整数）
)
//从上面获取所有整数并转换为一个列表
托利斯先生（）
//结果是列表
.订阅(
result->System.out.println（“*****”+result.toString（）+“*****”），
错误->新可丢弃文件（错误）
);

希望这有帮助。
我不知道RxJava api，但是如果它是Java流，那么您需要使用像
forEach
这样的终端操作，而不是
map
。也许RxJava就是这种情况？出于某种原因，我无法访问flowable。还有别的选择吗？可以用拉链拉吗<代码>可流动

和

单一

是同一套API的一部分。例如，您可以通过将

单个

转换为

可观察的

而不是

可流动的

来运行一组非常类似的操作。如果在RxJava中没有实现这一点的方法，那么集成RxJava2需要付出什么努力？

Lets consider below example to create List<Single<List<Integer>>> 

List<Integer> intList = new ArrayList<>();
Collections.addAll(intList, 10, 20, 30, 40, 50);

List<Integer> intList2 = new ArrayList<>();
Collections.addAll(intList2, 12, 22, 32, 42, 52);

List<Integer> intList3 = new ArrayList<>();
Collections.addAll(intList3, 13, 23, 33, 43, 53);

Single<List<Integer>> singleList = Single.just(intList);
Single<List<Integer>> singleList2 = Single.just(intList2);
Single<List<Integer>> singleList3 = Single.just(intList3);

List<Single<List<Integer>>> listOfSinglesOfListofInts = new ArrayList<>();

Collections.addAll(listOfSinglesOfListofInts, singleList, singleList2, singleList3);


Observable
    //Iterate through List<Singles>
    .fromIterable(listOfSinglesOfListofInts)
    //Get each single, convert to Observable and iterate to get all the integers
    .flatMap(
        singleListNew -> singleListNew
            .toObservable()
            //Iterate through each integer inside a list and return it
            .flatMapIterable(integers -> integers)
    )
    //Get all the integers from above and convert to one list
    .toList()
    //Result is List<Integer>
    .subscribe(
        result -> System.out.println("**** " + result.toString() + " ****"),
        error -> new Throwable(error)
    );