Question

假设我有两个A和B的流。

流1：A1，A2，A3，A4，A5，A6 流B：B1，B2，B3，B4

时间表：B1＆gt; A1＆gt; A2> B2＆gt; A3＆gt; A4＆gt; B3＆gt; A5 期望的输出：[B1＆amp; A1]，[A2＆amp; B2]，[B2＆amp; A3]，[A4＆amp; B3]，[B3＆amp; A5]，[A6＆amp; B4]

这反映了一个真实的生活过程，其中B是双面的并且堆叠在一起。例如，

---- B1 ----]
            |-1
---- A1 ----]

---- A2 ----]
            ]-2
---- B2 ----|]
            ]|-3
---- A3 ---- ]

---- A4 ----]
            |-4
---- B3 ----]]
             |-5
---- A5 ---- ]

---- A6 ----]
            |-6
---- B4 ----]

分组1是初始对的特征。分组6是终端配对的特征。可以重复第2/3和第4/5组。

我正在寻找有关如何使用RxJava2实现此目的的想法。

谢谢，Dan。

修改

我做了一个测试用例：

import java.util.Objects;

import org.junit.Test;

import io.reactivex.Flowable;
import io.reactivex.functions.BiFunction;
import io.reactivex.processors.FlowableProcessor;
import io.reactivex.processors.ReplayProcessor;

public class BuildControllerTest {
    @Test
    public void testProductBlanketSequencing() throws Exception {           
        final String a1="A1", a2="A2", a3="A3", a4="A4", a5="A5", a6="A6";
        final String b1="B1", b2="B2", b3="B3", b4="B4";

        class AB {
            String a;
            String b;

            public AB(String a, String b) {
                this.a = a;
                this.b = b;
            }

            @Override public boolean equals(Object obj) {
                if(getClass() != obj.getClass()) return false;
                if( ! Objects.equals(a, ((AB)obj).a)) return false;
                if( ! Objects.equals(b, ((AB)obj).b)) return false;
                return true;
            }
        }

        final FlowableProcessor<String> a = ReplayProcessor.create();
        final FlowableProcessor<String> b = ReplayProcessor.create();

        b.onNext(b1);
        a.onNext(a1);

        a.onNext(a2);
        b.onNext(b2);
        a.onNext(a3);

        a.onNext(a4);
        b.onNext(b3);
        a.onNext(a5);

        a.onNext(a6);
        b.onNext(b4);

        a.onComplete(); b.onComplete();

        Flowable.zip(a, b, new BiFunction<String, String, AB>() {
            @Override public AB apply(String t1, String t2) throws Exception {
                return new AB(t1, t2);
            }
        })
        .test()
        .assertResult(
                new AB(a1, b1), 
                new AB(a2, b2), 
                new AB(a3, b2), 
                new AB(a4, b3), 
                new AB(a5, b3), 
                new AB(a6, b4));
    }
}

Answer 1

从你的例子来看，不清楚什么条件会推动配对。

当我们使用zip时，只要两个来源都有下一个项目，就会形成对：

(A1, B1), (A2, B2), (A3, B3), (A4, B4)

如果我们使用combineLatest，当任何来源中有下一个项目时，就会形成该对：

(A1, B1), (A2, B1), (A2, B2), (A3, B2), (A4, B2), (A4, B3), (A5, B3), (A6, B3), (A6, B4)

对我来说，看起来你想要合并来源但不是每一对。您可以根据业务规则删除额外的对。

额外规则可以是时间，然后查看sampling。

Flowable.combineLatest(a, b, (t1, t2) -> new AB(t1, t2))
        .throttleLast(1, TimeUnit.MICROSECONDS)

它将从每个时间间隔的组合对中获取最新结果

(A1, B1), (A4, B3), (A5, B3), (A6, B3), (A6, B4)

如果额外的规则是来自源A的唯一值和来自B的可能重复，那么您可以使用distinct

Flowable.combineLatest(a, b, (t1, t2) -> new AB(t1, t2))
        .distinct(ab -> ab.a)

(A1, B1), (A2, B1), (A3, B2), (A4, B2), (A5, B3), (A6, B3)

'压缩'两个反应流，其中元素可重复使用

1 个答案: