Question

我有一个可观察到的字符串列表，另一个可观察到的字符串列表列表。我需要重用第一个可观察到的字符串，直到每个字符串都固定好为止

简而言之。我需要遍历列表列表的每个元素，并将其附加到第一个可观察的列表元素

我了解了retryWhen，但不知道如何重用第一个可观察的对象，然后继续使用第二个

val cat = sheetsViewer.GOOGLE_SHEETS_ENDPOINT_IMPL.readSpreadSheet(spreadsheetId, "A4:DA4")
            .toObservable()
            .flatMap { Observable.fromIterable(it) }


val data = sheetsViewer.GOOGLE_SHEETS_ENDPOINT_IMPL.readSpreadSheet(spreadsheetId, range)
            .toObservable()
            .subscribeOn(Schedulers.computation())
            .flatMap { Observable.fromIterable(it) }
            .map {
                val newList = it.toMutableList()

                while (newList.size != 105)
                    newList.add("")

                return@map newList
            }

我有字符串列表{“ a”，“ b”} 第二个{{“ a”，“ b”}，{“ c”，“ d”}，{“ e”，“ f”}}

我希望输出为{“ aa”，“ bb”，“ ca”，“ db”，“ ea”，“ fb”}

Answer 1

根据您的示例：

public static void main(String[] args) {
    final Flowable<List<String>> listOfStrings = Flowable.fromIterable(asList(asList("a", "b"),
                                                                       asList("c", "d"),
                                                                       asList("e", "f")));
    final Flowable<String> strings = Flowable.fromIterable(asList("a", "b"));

    listOfStrings.flatMap(list -> Flowable.zip(Flowable.fromIterable(list),
                                               strings,
                                              (s1, s2) -> s1 + s2))
                 .subscribe(System.out::println,
                            System.err::println);

    Flowable.timer(10, SECONDS) // Just to block the main thread for a while
            .blockingSubscribe();
}

我希望这会有所帮助。

Answer 2

我不确定“重用”是什么意思。如果这意味着您只希望订阅第一个可观察的对象一次，则可以执行以下操作（根据您的示例）：

fun main() {
    val listOfStringsObs = listOf("a", "b").toObservable()
    val listOfListOfStringsObs = listOf(
        listOf("a", "b"),
        listOf("c", "d"),
        listOf("e", "f")
    ).toObservable()

    listOfStringsObs
        .toList() // transforming Observable<String> to Single<List<String>> so we could subscribe on the single only once and then reuse the value
        .flatMapObservable { listOfStrings ->
            listOfListOfStringsObs
                .flatMap { element ->
                    element
                        .zip(listOfStrings) { a, b -> a + b } // zipping listOfStrings with each element from listOfListOfStrings by concatenating the strings
                        .toObservable()
                }
        }
        .subscribe(
            { println("Data: $it") },
            { println("Error: $it") },
            { println("Done") }
        )
}

有没有一种方法可以重用一个可观察的对象，直到第二个可以在zip中获得onComplete（）？

2 个答案: