RxJava使用詳解--組合操作符

RxJava使用詳解系列文章

《RxJava使用詳解--創建操作符》

《RxJava使用詳解--轉換操作符》

《RxJava使用詳解--過濾操作符》

詳細的例子可以查看文章末尾的源碼

這篇文章主要講RxJava中常見的組合操作符

1.combineLatest操作符把兩個Observable產生的結果進行合併，合併的結果組成一個新的Observable。下面的栗子是ob2中的每一個數據項都與ob1中的最後一項進行相加，將生成的結果組成一個新的Observable對象.

combineLatest操作符可以接受2-9個Observable作爲參數，最後一個Observable中的每一個數據項，都與前面Observable中的最後一項進行規則運算。也就是call方法中的最後一個值參數是最後一個Observable的每一項數據，
前面的參數是前面每一個Observable的最後一項數據，固定不變的。
combineLatest(List,FuncN)操作符可以接受一個Observable的list集合，集合中最後一個Observable中的每一項數據，會跟前面每一個Observable對象的最後一項數據進行規則運算
默認不在任何特定的調度器上執行。

Observable<Integer> ob1 = Observable.just(1,2,3);
Observable<Integer> ob2 = Observable.just(4,5,6);
Observable<Integer> ob3 = Observable.just(7,8,9);

List<Observable<Integer>> list = new ArrayList<>();
list.add(ob1);list.add(ob2);list.add(ob3);

Observable.combineLatest(ob1, ob2, new Func2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer integer, Integer integer2) {
        System.out.println("combineLatest(o1,o2,Func2):"+"o1:" + integer +" o2:"+ integer2 );
        return integer + integer2;//這裏進行合併的規則，可以用函數進行運算返回一個數據
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("combineLatest(o1,o2,Func2) onNext:" + integer);
    }
});

輸出結果：
combineLatest(o1,o2,Func2):o1:3 o2:4
combineLatest(o1,o2,Func2) onNext:7
combineLatest(o1,o2,Func2):o1:3 o2:5
combineLatest(o1,o2,Func2) onNext:8
combineLatest(o1,o2,Func2):o1:3 o2:6
combineLatest(o1,o2,Func2) onNext:9

Observable.combineLatest(ob1, ob2, ob3, new Func3<Integer, Integer, Integer, Integer>() {
    @Override//這裏進行合併的規則，可以用函數進行運算返回一個數據
    public Integer call(Integer integer, Integer integer2, Integer integer3) {
        System.out.println("combineLatest(o1,o2,o3,Func3):"+"o1:" + integer +" o2:"+ integer2 +" o3:"+ integer3);
        return integer + integer2 + integer3;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("combineLatest(o1,o2,o3,Func3) onNext:" + integer);
    }
});

輸出結果：
combineLatest(o1,o2,o3,Func3):o1:3 o2:6 o3:7
combineLatest(o1,o2,o3,Func3) onNext:16
combineLatest(o1,o2,o3,Func3):o1:3 o2:6 o3:8
combineLatest(o1,o2,o3,Func3) onNext:17
combineLatest(o1,o2,o3,Func3):o1:3 o2:6 o3:9
combineLatest(o1,o2,o3,Func3) onNext:18

Observable.combineLatest(list, new FuncN<String>() {
    @Override//這裏進行合併的規則，可以用函數進行運算返回一個數據
    public String call(Object... args) {
        String concat = "";
       for (Object value : args){
           System.out.println("combineLatest(List,FuncN) value:" + value);
           concat += value;
       }
        return concat;
    }
}).subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println("combineLatest(List,FuncN) onNext:" + s);
    }
});

輸出結果：
combineLatest(List,FuncN) value:3
combineLatest(List,FuncN) value:6
combineLatest(List,FuncN) value:7
combineLatest(List,FuncN) onNext:367
combineLatest(List,FuncN) value:3
combineLatest(List,FuncN) value:6
combineLatest(List,FuncN) value:8
combineLatest(List,FuncN) onNext:368
combineLatest(List,FuncN) value:3
combineLatest(List,FuncN) value:6
combineLatest(List,FuncN) value:9
combineLatest(List,FuncN) onNext:369

2.join操作符將兩個Observable產生的結果合併成一個新Observable對象，join操作符可以控制每個Observable產生結果的生命週期。

參數解釋 ob1.join(ob2,ob1產生結果生命週期控制函數，ob2產生結果生命週期控制函數，ob1和ob2合併結果的規則)
groupJoin()操作符第四個參數與join操作符不同，詳細的運行栗子查看

Observable<Integer> ob1 = Observable.just(1,2);
Observable<Integer> ob2 = Observable.just(3,4);
//join操作符
ob1.join(ob2, new Func1<Integer, Observable<Integer>>() {//ob1產生結果生命週期控制函數
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob1延遲200毫秒執行
        return Observable.just(integer).delay(200, TimeUnit.MILLISECONDS);
    }
}, new Func1<Integer, Observable<Integer>>() {//ob2產生結果聲明週期控制函數
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob2延遲200毫秒執行
        return Observable.just(integer).delay(200, TimeUnit.MILLISECONDS);
    }
}, new Func2<Integer, Integer, Integer>() {//ob1 和ob2產生結果的合併規則
    @Override
    public Integer call(Integer integer1, Integer integer2) {
        System.out.println("join(ob2,Func1,Func1,Func2) " + "integer1:" +integer1+ " integer2:" + integer2);
        return integer1 + integer2;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("join(ob2,Func1,Func1,Func2) " + integer);
    }
});

輸出結果：
join(ob2,Func1,Func1,Func2) integer1:1 integer2:3
join(ob2,Func1,Func1,Func2) 4
join(ob2,Func1,Func1,Func2) integer1:2 integer2:3
join(ob2,Func1,Func1,Func2) 5
join(ob2,Func1,Func1,Func2) integer1:1 integer2:4
join(ob2,Func1,Func1,Func2) 5
join(ob2,Func1,Func1,Func2) integer1:2 integer2:4
join(ob2,Func1,Func1,Func2) 6

//groupJoin操作符
ob1.groupJoin(ob2, new Func1<Integer, Observable<Integer>>() {//ob1產生結果生命週期控制函數
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob1延遲1600毫秒執行
        return Observable.just(integer).delay(1600, TimeUnit.MILLISECONDS);
    }
}, new Func1<Integer, Observable<Integer>>() {//ob2產生結果聲明週期控制函數
    @Override
    public Observable<Integer> call(Integer integer) {
        //使ob2延遲600毫秒執行
        return Observable.just(integer).delay(600, TimeUnit.MILLISECONDS);
    }
}, new Func2<Integer, Observable<Integer>, Observable<Integer>>() {
    @Override
    public Observable<Integer> call(final Integer integer1, Observable<Integer> observable) {
        return observable.map(new Func1<Integer, Integer>() {
            @Override
            public Integer call(Integer integer2) {
                System.out.println("groupJoin(ob2,Func1,Func1,Func2) " + "integer1:" + integer1 + " integer2:" + integer2);
                return integer1 + integer2;
            }
        });
    }
}). subscribe(new Action1<Observable<Integer>>() {
    @Override
    public void call(Observable<Integer> observable) {
        observable.subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("groupJoin(ob2,Func1,Func1,Func2) onNnext:" + integer);
            }
        });
    }
});

輸出結果：
groupJoin(ob2,Func1,Func1,Func2) integer1:1 integer2:3
groupJoin(ob2,Func1,Func1,Func2) onNnext:4
groupJoin(ob2,Func1,Func1,Func2) integer1:2 integer2:3
groupJoin(ob2,Func1,Func1,Func2) onNnext:5
groupJoin(ob2,Func1,Func1,Func2) integer1:1 integer2:4
groupJoin(ob2,Func1,Func1,Func2) onNnext:5
groupJoin(ob2,Func1,Func1,Func2) integer1:2 integer2:4
groupJoin(ob2,Func1,Func1,Func2) onNnext:6
3.merge操作符將多個Observalbe發射的數據項，合併到一個Observable中再發射出去，可能會讓合併的Observable發射的數據交錯（concat是連接不會出現交錯），如果在合併的途中出現錯誤，就會立即將錯誤提交給訂閱者，將終止合併後的Observable

mergeDelayError操作符類似於merge操作符，唯一不同就是如果在合併途中出現錯誤，不會立即發射錯誤通知，而是保留錯誤直到合併後的Observable將所有的數據發射完成，
此時纔會將onError提交給訂閱者。
合併多個Observable也可以通過傳遞一個Observalbe列表List、數組。

Observable<Integer> ob1 = Observable.just(1,2,3).delay(100, TimeUnit.MILLISECONDS);
Observable<Integer> ob2 = Observable.just(4,5,6)/*.delay(100, TimeUnit.MILLISECONDS)*/;

Observable.merge(ob1,ob2).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("merge(ob1,ob2) onNext:" + integer);
    }
});

輸出結果：

12-20 13:18:42.341 31603-31603/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:4
12-20 13:18:42.341 31603-31603/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:5
12-20 13:18:42.341 31603-31603/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:6
12-20 13:18:42.440 31603-31672/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:1
12-20 13:18:42.441 31603-31672/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:2
12-20 13:18:42.441 31603-31672/com.dingmouren.rxjavademo I/System.out: merge(ob1,ob2) onNext:3

4.startWith操作符是在源Observable提交結果之前插入指定的數據，可以是數值，也可以是Observable對象

Observable.just(1,2,3).startWith(0).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("startWith(T) onNext:" + integer);
    }
});
System.out.println(" - - - - - -  - - ");
Observable<Integer> ob2 = Observable.just(4,5,6);
Observable.just(1,2,3).startWith(ob2).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("startWith(T) onNext:" + integer);
    }
});

輸出結果：

startWith(T) onNext:0
startWith(T) onNext:1
startWith(T) onNext:2
startWith(T) onNext:3
 - - - - - -  - -
startWith(T) onNext:4
startWith(T) onNext:5
startWith(T) onNext:6
startWith(T) onNext:1
startWith(T) onNext:2
startWith(T) onNext:3

5.switchOnNext操作符是把一組Observable轉換成一個Observable，轉換規則爲：對於這組Observable中的每一個Observable所產生的結果，如果在同一個時間內存在兩個或多個Observable提交的結果，只取最後一個Observable提交的結果給訂閱者（看源碼中的例子）

6.zip操作符嚴格按照順序進行組合Observable，假設兩個Observable合併，ob1發射2個數據，ob2發射3個數據，最終合併的胡發射2個合併的數據。

zipWith操作符與上面類似，具體的看下面的例子
默認不在特定的調度器上執行

Observable<Integer> ob1 = Observable.just(1,2,3);
Observable<Integer> ob2 = Observable.just(4,5,6);

Observable.zip(ob1, ob2, new Func2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer integer1, Integer integer2) {
        System.out.println("zip(ob1,ob2,Func2) integer1:" + integer1 +" integer2:"+integer2);
        return integer1 + integer2;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("zip(ob1,ob2,Func2) onNext:" + integer);
    }
});
System.out.println("- - - - - - - -");
ob1.zipWith(ob2, new Func2<Integer, Integer, Integer>() {
    @Override
    public Integer call(Integer integer1, Integer integer2) {
        System.out.println("ob1.zipWith(ob2,Func2) integer1:" + integer1 +" integer2:"+integer2);
        return integer1 + integer2;
    }
}).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println("ob1.zipWith(ob2,Func2)  " + integer );
    }
});

輸出結果：

zip(ob1,ob2,Func2) integer1:1 integer2:4
zip(ob1,ob2,Func2) onNext:5
zip(ob1,ob2,Func2) integer1:2 integer2:5
zip(ob1,ob2,Func2) onNext:7
zip(ob1,ob2,Func2) integer1:3 integer2:6
zip(ob1,ob2,Func2) onNext:9
- - - - - - - -
ob1.zipWith(ob2,Func2) integer1:1 integer2:4
ob1.zipWith(ob2,Func2)  5
ob1.zipWith(ob2,Func2) integer1:2 integer2:5
ob1.zipWith(ob2,Func2)  7
ob1.zipWith(ob2,Func2) integer1:3 integer2:6
ob1.zipWith(ob2,Func2)  9

更多詳細內容和例子，可以查看源碼