Rxjava操作符彙總

原創 zhupumao 2020-06-07 17:59

《RxJavaEssentials》筆記
參考博客：http://www.tuicool.com/articles/A3uY7rF。

一、創建型操作符

1. just()

功能：將一個或多個對象轉換成發射這個或這些對象的一個Observable。
用法：

just=  Observable.just(1,3,4).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e("Just--------onCompleted","onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("Just-----------onError",e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.e("Just-----------OnNext","="+integer);
            }
        });

結果：
07-17 18:43:21.812 7734-7734/farmer.zpm.com.rxjavalearn E/Just———–OnNext: =1
07-17 18:43:21.812 7734-7734/farmer.zpm.com.rxjavalearn E/Just———–OnNext: =3
07-17 18:43:21.812 7734-7734/farmer.zpm.com.rxjavalearn E/Just———–OnNext: =4
07-17 18:43:21.812 7734-7734/farmer.zpm.com.rxjavalearn E/Just——–onCompleted: onCompleted

2.from()

功能：將一個Iterable, 一個Future, 或者一個數組轉換成一個Observable
用法：

 List<String> list=new ArrayList<String>();
        list.add("on");
        list.add("one");
        list.add("two");
        list.add("owe");
        Observable.from(list).subscribe(new Subscriber<String>() {
                    @Override
                    public void onCompleted() {
                        Log.e("from----onCompleted","onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.e("from---onError",e.getMessage());
                    }

                    @Override
                    public void onNext(String s) {
                        Log.i("from----OnNext","="+s);
                    }
                });

結果：
07-17 18:46:20.027 10313-10313/farmer.zpm.com.rxjavalearn I/from—-OnNext: =on
07-17 18:46:20.027 10313-10313/farmer.zpm.com.rxjavalearn I/from—-OnNext: =one
07-17 18:46:20.027 10313-10313/farmer.zpm.com.rxjavalearn I/from—-OnNext: =two
07-17 18:46:20.027 10313-10313/farmer.zpm.com.rxjavalearn I/from—-OnNext: =owe
07-17 18:46:20.027 10313-10313/farmer.zpm.com.rxjavalearn E/from—-onCompleted: onCompleted

3.repeat()

功能:創建一個重複發射指定數據或數據序列的Observable。
用法：

 repeat=  Observable.just(1,3,4)
                .repeat(2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e("repeat------onCompleted","onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("repeat---------onError",e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.e("repeat---------OnNext","="+integer);
            }
        });

結果：
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/repeat———OnNext: =1
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/repeat———OnNext: =3
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/repeat———OnNext: =4
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/repeat———OnNext: =1
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/repeat———OnNext: =3
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/repeat———OnNext: =4
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/repeat——onCompleted: onCompleted

4.defer()

功能：只有當訂閱者訂閱才創建Observable；爲每個訂閱創建一個新的Observable。
用法：

defer= Observable.defer(() -> Observable.just("defer"))
.subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.e("defer------onCompleted","onCompleted");
            }
            @Override
            public void onError(Throwable e) {
                Log.e("defer---------onError",e.getMessage());
            }
            @Override
            public void onNext(String s) {
                Log.e("defer---------OnNext","="+s);
            }
        });

結果：
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/defer———OnNext: =defer
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/defer——onCompleted: onCompleted

5.range()

功能：創建一個發射指定範圍的整數序列的Observable。
用法：

 range= Observable.range(10,3).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.e("range-------onCompleted","onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("range----------onError",e.getMessage());
            }

            @Override
            public void onNext(Integer integer) {
                Log.e("range----------OnNext","="+integer);
            }
        });

結果：
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/range———-OnNext: =10
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/range———-OnNext: =11
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/range———-OnNext: =12
07-17 18:50:00.275 13456-13456/farmer.zpm.com.rxjavalearn E/range——-onCompleted: onCompleted

6.interval()

功能： 創建一個按照給定的時間間隔發射整數序列的Observable
用法：
每隔3s發送一次

interval=  Observable.interval(3, TimeUnit.SECONDS)
            .subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {
                Log.e("interval----onCompleted","onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("interval---onError",e.getMessage());
            }

            @Override
            public void onNext(Long aLong) {
                Log.e("interval----OnNext","="+aLong);
            }
        });

結果：
07-17 18:51:52.671 13590-13613/farmer.zpm.com.rxjavalearn E/interval—-OnNext: =0
07-17 18:51:55.670 13590-13613/farmer.zpm.com.rxjavalearn E/interval—-OnNext: =1
07-17 18:51:58.670 13590-13613/farmer.zpm.com.rxjavalearn E/interval—-OnNext: =2
07-17 18:52:01.670 13590-13613/farmer.zpm.com.rxjavalearn E/interval—-OnNext: =3

7.timer()

功能：創建一個在給定的延時之後發射單個數據的Observable
用法：

timer_2= Observable.timer(3, TimeUnit.SECONDS)//每隔3s
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onCompleted() {
                        Log.e("timer----onCompleted","onCompleted");
                    }
                    @Override
                    public void onError(Throwable e) {
                        Log.e("timer---onError",e.getMessage());
                    }
                    @Override
                    public void onNext(Long number) {
                        Log.e("timer----OnNext","="+number);
                    }
                });

結果：
07-17 18:55:58.756 17166-17185/farmer.zpm.com.rxjavalearn E/timer—-OnNext: =0
07-17 18:55:58.756 17166-17185/farmer.zpm.com.rxjavalearn E/timer—-onCompleted: onCompleted

8.empty( )

功能：創建一個什麼都不做直接通知完成的Observable

9.error( )

功能：創建一個什麼都不做直接通知錯誤的Observable

10.never( )

功能： 創建一個不發射任何數據的Observable

二、過濾操作符

1.filter( )

功能： 過濾數據。
用法：
該例子打印以“o”開頭，“e”結尾的字符串。

List<String> list=new ArrayList<String>();
        list.add("on");
        list.add("one");
        list.add("two");
        list.add("owe");
      filter=  Observable.from(list)
      .filter(s -> s.startsWith("o"))
      .filter(s->s.endsWith("e"))
      .subscribe(new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.e("filter----onCompleted","onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("filter---onError",e.getMessage());
            }

            @Override
            public void onNext(String s) {
                Log.i("filter----OnNext","="+s);
            }
        });

結果：
07-17 18:57:35.067 18518-18518/farmer.zpm.com.rxjavalearn I/filter—-OnNext: =one
07-17 18:57:35.067 18518-18518/farmer.zpm.com.rxjavalearn I/filter—-OnNext: =owe
07-17 18:57:35.067 18518-18518/farmer.zpm.com.rxjavalearn E/filter—-onCompleted: onCompleted

2.take( ) takeLast()

功能： take( )只發射開始的N項數據，takeLast()只發射最後的N項數據。
這裏寫圖片描述
這裏寫圖片描述
用法：

  Observable.just(1,2,3,4,5,6,7,8,9,10)
                .take(4)
                .takeLast(2)
                .subscribe(integer -> {  Log.e("take------","="+integer);           });

結果：
07-17 18:57:35.069 18518-18518/farmer.zpm.com.rxjavalearn E/take——: =3
07-17 18:57:35.069 18518-18518/farmer.zpm.com.rxjavalearn E/take——: =4

3.distinct( ) distinctUntilChanged()

功能： distinct( )過濾掉重複數據;distinctUntilChanged()過濾掉連續重複的數據。
這裏寫圖片描述
用法：

 Observable.just(1,2,1,1,3,4,5).distinct().subscribe(integer -> {
            Log.e("distinct---","="+integer);
        });
        Observable.just(1,2,1,1,3,4,5).distinctUntilChanged().subscribe(integer -> {
            Log.e("distinctUntilChanged--","="+integer);
        });

結果：
07-17 18:57:35.069 18518-18518/farmer.zpm.com.rxjavalearn E/distinct—: =1
07-17 18:57:35.069 18518-18518/farmer.zpm.com.rxjavalearn E/distinct—: =2
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinct—: =3
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinct—: =4
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinct—: =5
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinctUntilChanged–: =1
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinctUntilChanged–: =2
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinctUntilChanged–: =1
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinctUntilChanged–: =3
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinctUntilChanged–: =4
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/distinctUntilChanged–: =5

4.first() last()

功能：first()只發射第一項數據，last()只發射最後的一項數據。
這裏寫圖片描述
這裏寫圖片描述
用法：

        Observable.just(1,2,3,4,5,6,7).first()
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("first","="+integer);
                    }
                });

結果：
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/first——: =1

5.skip() skipLast()

功能：skip( ) 跳過開始的N項數據,skipLast( ) — 跳過最後的N項數據。
這裏寫圖片描述
這裏寫圖片描述
用法：

 Observable.just(1,2,3,4,5,6,7).skip(3)
                .subscribe(integer -> {
                    Log.e("skip------","="+integer);
                });

結果：
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/skip——: =4
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/skip——: =5
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/skip——: =6
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/skip——: =7

6.elementAt( ) elementAtOrDefault( )

功能：elementAt( ) 發射第N項數據，elementAtOrDefault( )發射第N項數據，如果Observable數據少於N項就發射默認值。
這裏寫圖片描述
用法：

Observable.just(1,2,3,4,5,6,7).elementAt(3)
                .subscribe(integer -> {
                    Log.e("skip------","="+integer);
                });

結果：
07-17 18:57:35.070 18518-18518/farmer.zpm.com.rxjavalearn E/elementAt——: =4

7.sample( ) or throttleLast( )

功能： 定期發射Observable最近的數據。
這裏寫圖片描述
用法：

        Observable.interval(4,TimeUnit.SECONDS).sample(1, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
            @Override
            public void call(Long along) {
                Log.e("sample------","="+along);
            }
        });

結果：
07-17 19:02:03.684 22453-22478/farmer.zpm.com.rxjavalearn E/sample——: =0
07-17 19:02:07.685 22453-22478/farmer.zpm.com.rxjavalearn E/sample——: =1
07-17 19:02:11.684 22453-22478/farmer.zpm.com.rxjavalearn E/sample——: =2
07-17 19:02:15.684 22453-22478/farmer.zpm.com.rxjavalearn E/sample——: =3

8.throttleFirst( )

功能：定期發射Observable發射的第一項數據

9.throttleWithTimeout( ) or debounce( )

功能：只有當Observable在指定的時間後還沒有發射數據時，才發射一個數據。
用法：

  Observable.interval(5,TimeUnit.SECONDS).debounce(2,TimeUnit.SECONDS).subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                Log.e("debounce-----","="+aLong);
            }
        });

結果：
07-17 19:05:39.310 25326-25432/farmer.zpm.com.rxjavalearn E/debounce—–: =0
07-17 19:05:44.309 25326-25432/farmer.zpm.com.rxjavalearn E/debounce—–: =1
07-17 19:05:49.310 25326-25432/farmer.zpm.com.rxjavalearn E/debounce—–: =2
07-17 19:05:54.309 25326-25432/farmer.zpm.com.rxjavalearn E/debounce—–: =3

10.timeout( )

功能：如果在一個指定的時間段後還沒發射數據，就發射一個異常
這裏寫圖片描述
用法：

 Observable.interval(5, TimeUnit.SECONDS).timeout(3,TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
            @Override
            public void onCompleted() {
                Log.e("timeout----","onCompleted");
            }

            @Override
            public void onError(Throwable e) {
                Log.e("timeout----","onError");
            }

            @Override
            public void onNext(Long aLong) {
                Log.e("timeout----","="+aLong);
            }
        });

結果：
07-17 19:09:43.433 27390-27421/farmer.zpm.com.rxjavalearn E/timeout—-: onError

三、變換操作符

1.map()

功能：對序列的每一項都應用一個函數來變換Observable發射的數據序列。
這裏寫圖片描述
用法：

 Observable.just(1,2,3,4)
                .map(integer -> integer*10)
                .subscribe(integer -> {Log.i("map------","="+integer);});

結果：
07-17 19:24:58.783 9557-9557/farmer.zpm.com.rxjavalearn I/map——: =10
07-17 19:24:58.783 9557-9557/farmer.zpm.com.rxjavalearn I/map——: =20
07-17 19:24:58.783 9557-9557/farmer.zpm.com.rxjavalearn I/map——: =30
07-17 19:24:58.783 9557-9557/farmer.zpm.com.rxjavalearn I/map——: =40

2.FlatMap（）

功能：將Observable發射的數據集合變換爲Observables集合，然後將這些Observable發射的數據平坦化的放進一個單獨的Observable。
這裏寫圖片描述
用法：
http://blog.csdn.net/zhupumao/article/details/51893067
結果：
http://blog.csdn.net/zhupumao/article/details/51893067

3.scan()

功能：scan可以認爲具有累加器的功能，可以將前一個的值傳遞給後面使用。
這裏寫圖片描述
用法：

 Observable.just(1,2,3,4)
 .scan((integer, integer2) -> integer+integer2)
                .subscribe(integer -> {Log.e("scan----","="+integer);});

結果：
07-17 19:24:58.784 9557-9557/farmer.zpm.com.rxjavalearn E/scan—-: =1
07-17 19:24:58.784 9557-9557/farmer.zpm.com.rxjavalearn E/scan—-: =3
07-17 19:24:58.784 9557-9557/farmer.zpm.com.rxjavalearn E/scan—-: =6
07-17 19:24:58.784 9557-9557/farmer.zpm.com.rxjavalearn E/scan—-: =10

4.GroupBy()

功能：將原來的Observable轉變爲一個新的可以發射Observables的Observable，每一個Observable可以發射一組不同的數據。
這裏寫圖片描述
用法：

Observable.just(1,2,3,4,5,6,7,8,9)
                .groupBy(integer -> integer%3)
                .subscribe(result -> { result.subscribe(integer -> {
                Log.e("groupBy","key="+result.getKey()+"--value"+integer);
            });
        });

結果：
07-17 19:57:08.079 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=1–value1
07-17 19:57:08.079 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=2–value2
07-17 19:57:08.079 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=0–value3
07-17 19:57:08.079 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=1–value4
07-17 19:57:08.080 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=2–value5
07-17 19:57:08.080 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=0–value6
07-17 19:57:08.080 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=1–value7
07-17 19:57:08.080 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=2–value8
07-17 19:57:08.080 6995-6995/farmer.zpm.com.rxjavalearn E/groupBy: key=0–value9

5.buffer( )

功能： 它定期從Observable收集數據到一個集合，然後把這些數據集合打包發射，而不是一次發射一個。
這裏寫圖片描述
這裏寫圖片描述
用法：

 Observable.just(1,2,3,4,5,6,7,8,9).buffer(4).subscribe(integers -> {
            Log.e("buffer---","size="+integers.size());
            for (int i:integers ) {
                Log.e("buffer---","i="+i);
            }
        });

結果：
07-17 20:09:22.640 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: size=4
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=1
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=2
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=3
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=4
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: size=4
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=5
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=6
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=7
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=8
07-17 20:09:22.641 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: size=1
07-17 20:09:22.642 18252-18252/farmer.zpm.com.rxjavalearn E/buffer—: i=9
6.window( )
功能：和buffer()功能類似，只不過window發射的是Observables，buffer()發射的是List。
這裏寫圖片描述
7.cast()
功能：在發射之前強制將Observable發射的所有數據轉換爲指定類型。是map的特殊用法。
這裏寫圖片描述

四、結合型操作符

1.Merge

功能：將多個Observable合併爲一個。
這裏寫圖片描述
用法：

 Observable.interval(2,TimeUnit.SECONDS)
                .mergeWith(Observable.interval(1,TimeUnit.SECONDS))
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Log.e("mergeWith---","="+aLong);
                    }
                });

結果;

07-17 20:31:29.730 32130-32164/farmer.zpm.com.rxjavalearn E/mergeWith—: =0
07-17 20:31:30.730 32130-32163/farmer.zpm.com.rxjavalearn E/mergeWith—: =0
07-17 20:31:30.730 32130-32164/farmer.zpm.com.rxjavalearn E/mergeWith—: =1
07-17 20:31:31.730 32130-32164/farmer.zpm.com.rxjavalearn E/mergeWith—: =2
07-17 20:31:32.729 32130-32163/farmer.zpm.com.rxjavalearn E/mergeWith—: =1
07-17 20:31:32.730 32130-32164/farmer.zpm.com.rxjavalearn E/mergeWith—: =3
07-17 20:31:33.730 32130-32164/farmer.zpm.com.rxjavalearn E/mergeWith—: =4
07-17 20:31:34.729 32130-32163/farmer.zpm.com.rxjavalearn E/mergeWith—: =2
07-17 20:31:34.730 32130-32164/farmer.zpm.com.rxjavalearn E/mergeWith—: =5
07-17 20:31:35.730 32130-32164/farmer.zpm.com.rxjavalearn E/mergeWith—: =6

2.Zip

功能：使用一個函數組合多個Observable發射的數據集合，然後再發射這個結果。
這裏寫圖片描述
用法：

        Observable.interval(2, TimeUnit.SECONDS)
                .zipWith(Observable.just("one", "two"), new Func2<Long, String, String>() {
                    @Override
                    public String call(Long aLong, String s) {
                        return aLong+"="+s;
                    }
                })
                .subscribe(new Action1<String>() {
            @Override
            public void call(String s) {
                Log.e("zipWith---",s);
            }
        });

結果：//只有兩行
07-17 20:42:53.592 10788-10819/farmer.zpm.com.rxjavalearn E/zipWith—: 0=one
07-17 20:42:55.593 10788-10819/farmer.zpm.com.rxjavalearn E/zipWith—: 1=two
以後有空繼續更新！！！！！！

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Hot Observable 和 Cold Observable的區別

      HOT Observable Cold Observable   無論有沒有觀察者進行訂閱，事件始終都會發生 只有觀察者訂閱了，纔開始執行發射數據流的的帶啊嗎 關係 與訂閱者們的關係是一對多的關係，可以與多個訂閱者共享信息 與

异世界魔法开发者 2020-06-14 05:24:25

被觀察者 Observable（初稿）

异世界魔法开发者 2020-02-24 22:15:42

創建操作符（初稿）

异世界魔法开发者 2020-02-24 22:15:42

Android進階學習（4）-- RxJava 從源碼角度學習理解

孙先森i 2020-02-22 05:06:25

手把手教你使用 RxJava 2.0（一）

LRH0211 2020-02-20 19:44:31

手把手教你使用 RxJava 2.0（三）

LRH0211 2020-02-20 19:44:31

手把手教你使用 RxJava 2.0（二）

LRH0211 2020-02-20 19:44:30

RxJava的基礎知識

krauser1991 2019-06-11 05:13:33

Android框架——RxJava（一）概述與基本使用

蓝十一丶 2018-09-20 09:07:58

Android框架——RxJava（二）創建操作符

蓝十一丶 2018-09-20 09:07:58

Android框架——RxJava（三）轉換操作符

蓝十一丶 2018-09-20 09:07:58

操作符 ---- create

三月初七丶 2018-09-06 02:53:22

RxJava1.6訂閱和取消訂閱

业大神 2018-09-05 03:05:42

RxJava 嵌套調用接口

业大神 2018-09-05 03:05:42

Rxjava之map()的運用

zhupumao 2018-09-04 17:21:24