RxJava操作符之組合操作符(六)

LeiHolmes發表於2019-03-04
RxJava

前言

　　上一篇文章我們學習了過濾類操作符，本篇我們將一起來學習RxJava組合類操作符。組合操作符主要是用來同時處理多個Observable，將他們進行組合建立出新的滿足我們需求的Observable，一起來看下都有哪些。
　　

組合操作符

Merge

　　merge操作符，將兩個Observable要發射的觀測序列合併為一個序列進行發射。按照兩個序列每個元素的發射時間先後進行排序，同一時間點發射的元素則是無序的。

//將一個傳送字母的Observable與傳送數字的Observable合併發射
final String[] words = new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "I"};
//字母Observable，每200ms發射一次
Observable<String> wordSequence = Observable.interval(200, TimeUnit.MILLISECONDS)
        .map(new Func1<Long, String>() {
            @Override
            public String call(Long position) {
                return words[position.intValue()];
            }
        })
        .take(words.length);
//數字Observable，每500ms發射一次
Observable<Long> numberSequence = Observable.interval(500, TimeUnit.MILLISECONDS).take(4);
Observable.merge(wordSequence, numberSequence)
        .subscribe(new Action1<Serializable>() {
            @Override
            public void call(Serializable serializable) {
                Log.e("rx_test", "merge：" + serializable.toString());
            }
        });複製程式碼

　　輸出結果：

merge：A
merge：B
merge：0
merge：C
merge：D
merge：E
merge：1
merge：F
merge：G
merge：2
merge：H
merge：I
merge：3複製程式碼

　　原理圖：

　　merge操作符還有一種入參merge(Observable[]),可傳入含有多個Observable的集合，merge操作符也可將這多個Observable的序列合併後發射。

MergeDelayError

　　mergeDelayError操作符，與merge功能類似，都是用來合併Observable的。不同之處在於mergeDelayError操作符在合併過程中發生異常的話不會立即停止合併，而會在所有元素合併發射完畢之後再發射異常。但發生異常的那個Observable就不會發射資料了。

//字母Observable，每200ms發射一次，模擬過程中產生一個異常
Observable<String> wordSequence = Observable.interval(200, TimeUnit.MILLISECONDS)
        .map(new Func1<Long, String>() {
            @Override
            public String call(Long position) {
                Long cache = position;
                if (cache == 3) {
                    cache = cache / 0;
                }
                return words[position.intValue()];
            }
        })
        .take(words.length);
//數字Observable，每500ms發射一次
Observable<Long> numberSequence = Observable.interval(500, TimeUnit.MILLISECONDS).take(4);
Observable.mergeDelayError(wordSequence, numberSequence)
        .subscribe(new Action1<Serializable>() {
            @Override
            public void call(Serializable serializable) {
                Log.e("rx_test", "mergeDelayError：" + serializable.toString());
            }
        }, new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                Log.e("rx_test", "mergeDelayError：" + throwable.getMessage());
            }
        }, new Action0() {
            @Override
            public void call() {
                Log.e("rx_test", "mergeDelayError：onComplete");
            }
        });複製程式碼

　　輸出結果：

mergeDelayError：A
mergeDelayError：B
mergeDelayError：0
mergeDelayError：C
mergeDelayError：1
mergeDelayError：2
mergeDelayError：3
mergeDelayError：divide by zero複製程式碼

　　由輸出結果可看出，wordSequence在發射到C時丟擲了一個異常，停止發射其剩下的資料，但合併沒有停止。合併完成之後這個異常才被髮射了出來。
　　原理圖：

Concat

　　concat操作符，將多個Obserbavle發射的資料進行合併後發射，類似於merge操作符。但concat操作符是將Observable依次發射，是有序的。

Observable<String> wordSequence = Observable.just("A", "B", "C", "D", "E");
Observable<Integer> numberSequence = Observable.just(1, 2, 3, 4, 5);
Observable<String> nameSequence = Observable.just("Sherlock", "Holmes", "Xu", "Lei");
Observable.concat(wordSequence, numberSequence, nameSequence)
        .subscribe(new Action1<Serializable>() {
            @Override
            public void call(Serializable serializable) {
                Log.e("rx_test", "concat：" + serializable.toString());
            }
        });複製程式碼

　　輸出結果：

concat：A
concat：B
concat：C
concat：D
concat：E
concat：1
concat：2
concat：3
concat：4
concat：5
concat：Sherlo
concat：Holmes
concat：Xu
concat：Lei複製程式碼

　　原理圖：

Zip

　　zip(Observable, Observable, Func2)操作符，根據Func2中的call()方法規則合併兩個Observable的資料項併發射。
　　注意：若其中一個Observable資料傳送結束或出現異常後，另一個Observable也會停止發射資料。

Observable<String> wordSequence = Observable.just("A", "B", "C", "D", "E");
Observable<Integer> numberSequence = Observable.just(1, 2, 3, 4, 5, 6);
Observable.zip(wordSequence, numberSequence, new Func2<String, Integer, String>() {
    @Override
    public String call(String s, Integer integer) {
        return s + integer;
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        Log.e("rx_test", "zip：" + s);
    }
});複製程式碼

　　輸出結果：

zip：A1
zip：B2
zip：C3
zip：D4
zip：E5複製程式碼

　　由輸出結果可看出numberSequence觀測序列最後的6並沒有發射出來，由於wordSequence觀測序列已發射完所有資料，所以組合序列也停止發射資料了。
　　原理圖：

StartWith

　　startWith操作符，用於在源Observable發射的資料前，插入指定的資料併發射。

Observable.just(4, 5, 6, 7)
        .startWith(1, 2, 3)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.e("rx_test", "startWith：" + integer);
            }
        });複製程式碼

　　輸出結果：

startWith：1
startWith：2
startWith：3
startWith：4
startWith：5
startWith：6
startWith：7複製程式碼

　　原理圖：

　　startWith還有兩種入參：

  • startWith(Iterable)：可在源Observable發射的資料前插入Iterable資料併發射。
  • startWith(Observable)：可在源Observable發射的資料前插入另一Observable發射的資料併發射。

    SwitchOnNext

    　　switchOnNext操作符，用來將一個發射多個小Observable的源Observable轉化為一個Observable，然後發射多個小Observable所發射的資料。若小Observable正在發射資料時，源Observable又發射了新的小Observable，則前一個小Observable還未發射的資料會被拋棄，直接發射新的小Observable所發射的資料，上例子。
    ```java
    //每隔500ms產生一個Observable
    Observable> observable = Observable.interval(500, TimeUnit.MILLISECONDS)
      .map(new Func1<Long, Observable<Long>>() {
      @Override
      public Observable<Long> call(Long aLong) {
          //每隔200毫秒產生一組資料（0,10,20,30,40)
          return Observable.interval(200, TimeUnit.MILLISECONDS)
                  .map(new Func1<Long, Long>() {
                      @Override
                      public Long call(Long aLong) {
                          return aLong * 10;
                      }
                  }).take(5);
          }
  }).take(2);複製程式碼

Observable.switchOnNext(observable)
.subscribe(new Action1() {
@Override
public void call(Long aLong) {
Log.e("rx_test", "switchOnNext：" + aLong);
}
});

　　輸出結果：
```java
switchOnNext：0
switchOnNext：10
switchOnNext：0
switchOnNext：10
switchOnNext：20
switchOnNext：30
switchOnNext：40複製程式碼

　　由輸出結果發現第一個小Observable列印到10則停止了發射資料，說明其發射到10時，新的小Observable被建立了出來，第一個小Observable則被中斷髮射，開始發射新的小Observable的資料。
　　原理圖：

CombineLatest

　　combineLatest操作符，用於將兩個Observale最近發射的資料以Func2函式的規則進行組合併發射。

//引用merge的例子
final String[] words = new String[]{"A", "B", "C", "D", "E", "F", "G", "H", "I"};
Observable<String> wordSequence = Observable.interval(300, TimeUnit.MILLISECONDS)
        .map(new Func1<Long, String>() {
            @Override
            public String call(Long position) {
                return words[position.intValue()];
            }
        })
        .take(words.length);
Observable<Long> numberSequence = Observable.interval(500, TimeUnit.MILLISECONDS)
        .take(5);
Observable.combineLatest(wordSequence, numberSequence,
        new Func2<String, Long, String>() {
            @Override
            public String call(String s, Long aLong) {
                return s + aLong;
            }
        })
        .subscribe(new Action1<Serializable>() {
            @Override
            public void call(Serializable serializable) {
                Log.e("rx_test", "combineLatest：" + serializable.toString());
            }
        });複製程式碼

　　輸出結果：

combineLatest：A0
combineLatest：B0
combineLatest：C0
combineLatest：C1
combineLatest：D1
combineLatest：E1
combineLatest：E2
combineLatest：F2
combineLatest：F3
combineLatest：G3
combineLatest：H3
combineLatest：H4
combineLatest：I4複製程式碼

　　如果將wordSequence與numberSequence的入參順序互換，輸出結果也會不同：

combineLatest：0A
combineLatest：0B
combineLatest：0C
combineLatest：1C
combineLatest：1D
combineLatest：2D
combineLatest：2E
combineLatest：2F
combineLatest：3F
combineLatest：3G
combineLatest：3H
combineLatest：4H
combineLatest：4I複製程式碼

　　wordSequence每300ms發射一個字元，numberSequence每500ms發射一個數字。可能有些碼友不知道這個輸出結果怎麼來的，這個操作符確實不太好理解。我們來看一下這個原理圖就很清楚了。
　　原理圖：

Join

　　join(Observable, Func1, Func1, Func2)操作符，類似於combineLatest操作符，用於將ObservableA與ObservableB發射的資料進行排列組合。但join操作符可以控制Observable發射的每個資料的生命週期，在每個發射資料的生命週期內，可與另一個Observable發射的資料按照一定規則進行合併，來看下join的幾個入參。

  • Observable：需要與源Observable進行組合的目標Observable。
  • Func1：接收從源Observable發射來的資料，並返回一個Observable，這個Observable的宣告週期決定了源Obsrvable發射出來的資料的有效期；
  • Func1：接收目標Observable發射來的資料，並返回一個Observable，這個Observable的宣告週期決定了目標Obsrvable發射出來的資料的有效期；
  • Func2：接收從源Observable和目標Observable發射出來的資料，並將這兩個資料按自定的規則組合後返回。
    //產生字母的序列,週期為1000ms
String[] words = new String[]{"A", "B", "C", "D", "E", "F", "G", "H"};
Observable<String> observableA = Observable.interval(1000, TimeUnit.MILLISECONDS)
      .map(new Func1<Long, String>() {
          @Override
          public String call(Long aLong) {
              return words[aLong.intValue()];
          }
      }).take(8);
//產0,1,2,3,4,5,6,7的序列,延時500ms發射,週期為1000ms
Observable<Long> observableB = Observable.interval(500, 1000, TimeUnit.MILLISECONDS)
      .map(new Func1<Long, Long>() {
          @Override
          public Long call(Long aLong) {
              return aLong;
          }
      }).take(words.length);
//join
observableA.join(observableB,
      new Func1<String, Observable<Long>>() {
          @Override
          public Observable<Long> call(String s) {
              //ObservableA發射的資料有效期為600ms
              return Observable.timer(600, TimeUnit.MILLISECONDS);
          }
      },
      new Func1<Long, Observable<Long>>() {
          @Override
          public Observable<Long> call(Long aLong) {
              //ObservableB發射的資料有效期為600ms
              return Observable.timer(600, TimeUnit.MILLISECONDS);
          }
      },
      new Func2<String, Long, String>() {
          @Override
          public String call(String s, Long aLong) {
              return s + aLong;
          }
      }
).subscribe(new Action1<String>() {
  @Override
  public void call(String s) {
      Log.e("rx_test", "join：" + s);
  }
});複製程式碼
    　　join操作符的組合方式類似於數學上的排列組合規則，以ObservableA為基準源Observable，按照其自身週期發射資料，且每個發射出來的資料都有其有效期。而ObservableB每發射出來一個資料，都與A發射出來的並且還在有效期內的資料按Func2函式中的規則進行組合，B發射出來的資料也有其有效期。最後再將結果發射給觀察者進行處理。
    　　輸出結果：
    join：A0
join：A1
join：B1
join：B2
join：C2
join：C3
join：D3
join：D4
join：E4
join：E5
join：F5
join：F6
join：G6
join：G7
join：H7複製程式碼
    　　原理圖：

GroupJoin

　　groupJoin操作符，類似於join操作符，區別在於第四個引數Func2的傳入函式不同，對join之後的結果包裝了一層小的Observable，便於使用者再次進行一些過濾轉換等操作再發射給Observable。

observableA.groupJoin(observableB,
        new Func1<String, Observable<Long>>() {
            @Override
            public Observable<Long> call(String s) {
                return Observable.timer(600, TimeUnit.MILLISECONDS);
            }
        },
        new Func1<Long, Observable<Long>>() {
            @Override
            public Observable<Long> call(Long aLong) {
                return Observable.timer(600, TimeUnit.MILLISECONDS);
            }
        },
        new Func2<String, Observable<Long>, Observable<String>>() {
            @Override
            public Observable<String> call(final String s, Observable<Long> longObservable) {
                return longObservable.map(new Func1<Long, String>() {
                    @Override
                    public String call(Long aLong) {
                        return s + aLong;
                    }
                });
            }
        })
        .subscribe(new Action1<Observable<String>>() {
            @Override
            public void call(Observable<String> stringObservable) {
                stringObservable.subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Log.e("rx_test", "groupJoin：" + s);
                    }
                });
            }
        });複製程式碼

　　輸出結果：

groupJoin：A0
groupJoin：A1
groupJoin：B1
groupJoin：B2
groupJoin：C2
groupJoin：C3
groupJoin：D3
groupJoin：D4
groupJoin：E4
groupJoin：E5
groupJoin：F5
groupJoin：F6
groupJoin：G6
groupJoin：G7
groupJoin：H7複製程式碼

　　原理圖：

總結

　　到此，本篇關於RxJava的常用組合類操作符就講解完畢了。通過以上四篇文章對RxJava四類操作符的學習，相信大家已經基本掌握RxJava如何使用了。實踐是檢驗真理的唯一標準，下一篇我們來一起上專案看看實踐中如何使用RxJava。
　　技術渣一枚，有寫的不對的地方歡迎大神們留言指正，有什麼疑惑或者建議也可以在我Github上RxJavaDemo專案Issues中提出，我會及時回覆。
　　附上RxJavaDemo的地址：
　　RxJavaDemo

相關文章