'Zipping' two reactive streams where elements are reusable - reactive-programming

Question

Suppose I have two streams of A's and B's.
Stream 1: A1, A2, A3, A4, A5, A6
Stream B: B1, B2, B3, B4
Timeline: B1 > A1 > A2 > B2 > A3 > A4 > B3 > A5
Desired output: [B1 & A1], [A2 & B2], [B2 & A3], [A4 & B3], [B3 & A5], [A6 & B4]
This mirrors a real life process where B's are double sided and stacked together. For example,
---- B1 ----]
|-1
---- A1 ----]
---- A2 ----]
]-2
---- B2 ----|]
]|-3
---- A3 ---- ]
---- A4 ----]
|-4
---- B3 ----]]
|-5
---- A5 ---- ]
---- A6 ----]
|-6
---- B4 ----]
Grouping 1 is characteristic of the initial pair. Grouping 6 is characteristic of the terminal pairing. Groups 2/3 and 4/5 can be repeated.
I'm looking for ideas on how to achieve this with RxJava2.
Thanks, Dan.
EDIT
I made a test case:
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

From your example it is not clear what condition drives pairing.
When we use zip the pair is formed as soon as both sources has next item:
(A1, B1), (A2, B2), (A3, B3), (A4, B4)
If we use combineLatest the pair is formed when there is next item in any source:
(A1, B1), (A2, B1), (A2, B2), (A3, B2), (A4, B2), (A4, B3), (A5, B3), (A6, B3), (A6, B4)
For me it looks like you want to combine sources but take not every pair. You can remove extra pairs depending on business rules.
The extra rule can be time, then take look at sampling.
Flowable.combineLatest(a, b, (t1, t2) -> new AB(t1, t2))
.throttleLast(1, TimeUnit.MICROSECONDS)
it will take latest result from combined pairs every time interval
(A1, B1), (A4, B3), (A5, B3), (A6, B3), (A6, B4)
If extra rules is to have unique values from source A and posible repeats from B then you can use 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)