Zip
使用指定函数按顺序结合两个或多个 Observables 发射的数据项，然后发射这个函数返回的结果。它按照严格的顺序应用这个函数。它只发射与发射数据项最少的那个Observable一样多的数据。

zip 默认不在任何特定的操作符上执行。

Observable<Integer> observable1 = Observable.just(1, 3, 5);
Observable<Integer> observable2 = Observable.just(2, 4, 6, 8);
Observable.zip(observable1, observable2, (integer, integer2) -> integer + "-" + integer2)
        .subscribe(s -> System.out.println(System.currentTimeMillis() + " - accept : " + s));
 
结果：

1601433571245 - accept : 1-2
1601433571246 - accept : 3-4
1601433571246 - accept : 5-6

Merge
将多个 Observables 的输出项合并为一个 Observable。

Merge 可能会让合并的 Observables 发射的数据交错

Observable<Integer> observable1 = Observable.just(1, 3, 5)
         .flatMap((Function<Integer, ObservableSource<Integer>>) integer -> Observable.just(integer).delay(integer, TimeUnit.SECONDS));
 Observable<Integer> observable2 = Observable.just(2, 4, 6, 8)
         .flatMap((Function<Integer, ObservableSource<Integer>>) integer -> Observable.just(integer).delay(integer, TimeUnit.SECONDS));

 Observable.merge(observable1, observable2)
         .subscribe(integer -> System.out.println(System.currentTimeMillis() + " - accept : " + integer));
 
结果：

1601433692203 - accept : 1
1601433693211 - accept : 2
1601433694206 - accept : 3
1601433695214 - accept : 4
1601433696208 - accept : 5
1601433697217 - accept : 6
1601433699220 - accept : 8

StartWith
在数据序列的开发插入一条指定的项。

Observable<Integer> observable1 = Observable.just(1, 3, 5);
Observable<Integer> observable2 = Observable.just(2, 4, 6, 8);

observable1.startWith(observable2)
        .subscribe(integer -> System.out.println(System.currentTimeMillis() + " - accept : " + integer));
 
结果：

1601433776805 - accept : 2
1601433776806 - accept : 4
1601433776806 - accept : 6
1601433776806 - accept : 8
1601433776806 - accept : 1
1601433776806 - accept : 3
1601433776806 - accept : 5

CombineLatest
当两个 Observables 中的任何一个发射了数据时，使用一个函数结合每个 Observable 发射的最近数据项，并且基于这个函数的结果发射数据。

Observable<Integer> observable1 = Observable.just(1, 3, 5)
        .flatMap((Function<Integer, ObservableSource<Integer>>) integer -> Observable.just(integer).delay(integer, TimeUnit.SECONDS));
Observable<Integer> observable2 = Observable.just(2, 4, 6)
        .flatMap((Function<Integer, ObservableSource<Integer>>) integer -> Observable.just(integer).delay(integer * 800, TimeUnit.MILLISECONDS));

Observable.combineLatest(observable1, observable2, (integer, integer2) -> integer + "-" + integer2)
        .subscribe(integer -> System.out.println(System.currentTimeMillis() + " - accept : " + integer));
 
结果：

1601433835043 - accept : 1-2
1601433836439 - accept : 3-2
1601433836643 - accept : 3-4
1601433838245 - accept : 3-6
1601433838441 - accept : 5-6

Join
任何时候，只要在另一个 Observable 发射的数据定义的时间窗口内，这个 Observable 发射了一条数据，就结合两个 Observable 发射的数据。

join 默认不在任何特定的调度器上执行。

Observable<Integer> observable1 = Observable.just(1, 3, 5)
         .flatMap((Function<Integer, ObservableSource<Integer>>) integer -> Observable.just(integer).delay(integer, TimeUnit.SECONDS));
 Observable<Integer> observable2 = Observable.just(2, 4, 6)
         .flatMap((Function<Integer, ObservableSource<Integer>>) integer -> Observable.just(integer).delay(integer * 800, TimeUnit.MILLISECONDS));

 observable1.join(observable2,
         integer -> Observable.timer(2, TimeUnit.SECONDS),
         integer -> Observable.timer(1, TimeUnit.SECONDS),
         (integer, integer2) -> integer + "-" + integer)
     .subscribe(integer -> System.out.println(System.currentTimeMillis() + " - accept : " + integer));
 
结果：

1601433929893 - accept : 1-1
1601433931496 - accept : 3-3
1601433933099 - accept : 3-3
1601433933290 - accept : 5-5

SwitchOnNext
将一个发射多个 Observables 的Observable 转换成另一个单独的 Observable，后者发射那些 Observables 最近发射的数据项。

switchOnNext 默认不在任何特定的调度器上执行。

Observable.switchOnNext(
        Observable.interval(100, TimeUnit.MICROSECONDS)
            .map((Function<Long, ObservableSource<?>>) aLong -> Observable.interval(30, TimeUnit.MICROSECONDS)
                    .map(aLong2 -> aLong)))
        .take(8)
        .subscribe(integer -> System.out.println(System.currentTimeMillis() + " - accept : " + integer));
 
结果：

1601434015428 - accept : 0
1601434015430 - accept : 1
1601434015431 - accept : 3
1601434015433 - accept : 5
1601434015436 - accept : 9
1601434015437 - accept : 10
1601434015437 - accept : 11
1601434015438 - accept : 12

And/Then/When
使用 Pattern 和 Plan 作为中介，将两个或多个 Observable 发射的数据集合并在一起。

它们的组合行为类似于zip，但是它们使用一个中间数据结构。接受两个或多个Observable，一次一个将它们的发射物合并到Pattern对象，然后操作那个Pattern对象，变换为一个Plan。随后将这些Plan变换为Observable的发射物。

它们属于 rxjava-joins 模块，不是核心 RxJava 包的一部分。
————————————————

原文链接：https://blog.csdn.net/doris_d/article/details/108846965