Question

给出两个可观察的流{1,3}和{2,4}，那里有任何运算符可以产生以下结果： {1,2,3,4}

我认为合并是为此而做的

List<Integer> result=Observable.merge(Observable.fromIterable(Arrays.asList(1,3)),Observable.fromIterable(Arrays.asList(2,4))).toList().blockingGet();

但是后来我发现合并“可以”交错，但是只要执行同步操作就不会。

有指针吗？

Answer 1

没有标准的运算符。您可以尝试将项目映射到（索引，值）元组，其中第一个来源的索引为0、2、4等，第二个来源的索引为1、3、5。然后使用orderedMerge比较元组的索引，然后在合并后提取值。

类似这样的东西：

AtomicInteger index1 = new AtomicInteger();
Flowable<Pair<Integer, T>> indexedSource1 = source1
    .map(v -> new Pair<>(index1.getAndAdd(2), v));

AtomicInteger index2 = new AtomicInteger(1);
Flowable<Pair<Integer, T>> indexedSource2 = source2
    .map(v -> new Pair<>(index2.getAndAdd(2), v));

Flowables.orderedMerge(
    (a, b) -> a.first.compareTo(b.first), 
    indexedSource1, 
    indexedSource2
)
.map(v -> v.second);

Answer 2

我还有另一种方法。从上面给出的解决方案中看不出明显的好处。但是，它仅使用常规的zip运算符即可达到结果。

        List<Integer> intArray1 = Arrays.asList(1,3,5,7);
        List<Integer> intArray2 = Arrays.asList(2,4,6,8);
        Observable.zip(
                Observable.fromIterable(intArray1),
                Observable.fromIterable(intArray2),
                (numbers1, numbers2) -> new Pair<>(numbers1, numbers2)).
                collect(ArrayList<Integer>::new,
                        (list, pair) -> {
                            list.add(pair.first);
                            list.add(pair.second);
                        }).
                subscribe(mergedList -> {
                    Log.d("List", mergedList.size() + "");
                });

Answer 3

如果源是冷可观测的，并且如果我需要组合源的元素，则可以使用zip：

    Observable<Integer> stream1 = Observable.fromIterable(Arrays.asList(1, 3));
    Observable<Integer> stream2 = Observable.fromIterable(Arrays.asList(2, 4));

    List<Integer> integers = Observable.zip(stream1, stream2, (a, b) -> Observable.just(a, b))
            .flatMap(ob -> ob)
            .toList()
            .blockingGet();

与Rxjava2

3 个答案: