Android RxJava使用介紹（三） RxJava的操作符

yangxi_001發表於2016-04-27

AndroidRxJava

上一篇文章已經詳細講解了RxJava的建立型操作符，本片文章將繼續講解RxJava操作符，包括：

Transforming Observables(Observable的轉換操作符)
Filtering Observables(Observable的過濾操作符)

Transforming Observables(Observable的轉換操作符)

buffer操作符

buffer操作符週期性地收集源Observable產生的結果到列表中，並把這個列表提交給訂閱者，訂閱者處理後，清空buffer列表，同時接收下一次收集的結果並提交給訂閱者，周而復始。

需要注意的是，一旦源Observable在產生結果的過程中出現異常，即使buffer已經存在收集到的結果，訂閱者也會馬上收到這個異常，並結束整個過程。

buffer的名字很怪，但是原理很簡單，流程圖如下：
這裡寫圖片描述

呼叫例子如下：

//定義郵件內容
        final String[] mails = new String[]{"Here is an email!", "Another email!", "Yet another email!"};
        //每隔1秒就隨機發布一封郵件
        Observable<String> endlessMail = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                try {
                    if (subscriber.isUnsubscribed()) return;
                    Random random = new Random();
                    while (true) {
                        String mail = mails[random.nextInt(mails.length)];
                        subscriber.onNext(mail);
                        Thread.sleep(1000);
                    }
                } catch (Exception ex) {
                    subscriber.onError(ex);
                }
            }
        }).subscribeOn(Schedulers.io());
        //把上面產生的郵件內容快取到列表中，並每隔3秒通知訂閱者
        endlessMail.buffer(3, TimeUnit.SECONDS).subscribe(new Action1<List<String>>() {
            @Override
            public void call(List<String> list) {

                System.out.println(String.format("You've got %d new messages!  Here they are!", list.size()));
                for (int i = 0; i < list.size(); i++)
                    System.out.println("**" + list.get(i).toString());
            }
        });

執行結果如下：
You’ve got 3 new messages! Here they are!(after 3s)
**Here is an email!
**Another email!
**Another email!
You’ve got 3 new messages! Here they are!(after 6s)
**Here is an email!
**Another email!
**Here is an email!
……

flatMap操作符

flatMap操作符是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。

flatMap操作符通過傳入一個函式作為引數轉換源Observable，在這個函式中，你可以自定義轉換規則，最後在這個函式中返回一個新的Observable，然後flatMap操作符通過合併這些Observable結果成一個Observable，並依次提交結果給訂閱者。

值得注意的是，flatMap操作符在合併Observable結果時，有可能存在交叉的情況，如下流程圖所示：
這裡寫圖片描述

呼叫例子如下：

private Observable<File> listFiles(File f){
        if(f.isDirectory()){
            return Observable.from(f.listFiles()).flatMap(new Func1<File, Observable<File>>() {
                @Override
                public Observable<File> call(File file) {
                    return listFiles(f);
                }
            });
        } else {
            return Observable.just(f);
        }
    }


    @Override
    public void onClick(View v) {
        Observable.just(getApplicationContext().getExternalCacheDir())
                .flatMap(new Func1<File, Observable<File>>() {
                    @Override
                    public Observable<File> call(File file) {
                        //引數file是just操作符產生的結果，這裡判斷file是不是目錄檔案，如果是目錄檔案，則遞迴查詢其子檔案flatMap操作符神奇的地方在於，返回的結果還是一個Observable，而這個Observable其實是包含多個檔案的Observable的，輸出應該是ExternalCacheDir下的所有檔案
                        return listFiles(file);
                    }
                })
                .subscribe(new Action1<File>() {
                    @Override
                    public void call(File file) {
                        System.out.println(file.getAbsolutePath());
                    }
                });

    }

concatMap操作符

cancatMap操作符與flatMap操作符類似，都是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。

與flatMap操作符不同的是，concatMap操作符在處理產生的Observable時，採用的是“連線(concat)”的方式，而不是“合併(merge)”的方式，這就能保證產生結果的順序性，也就是說提交給訂閱者的結果是按照順序提交的，不會存在交叉的情況。

concatMap的流程如下：
這裡寫圖片描述

concatMap的呼叫例子與flatMap類似，這裡不做重複

switchMap操作符

switchMap操作符與flatMap操作符類似，都是把Observable產生的結果轉換成多個Observable，然後把這多個Observable“扁平化”成一個Observable，並依次提交產生的結果給訂閱者。

與flatMap操作符不同的是，switchMap操作符會儲存最新的Observable產生的結果而捨棄舊的結果，舉個例子來說，比如源Observable產生A、B、C三個結果，通過switchMap的自定義對映規則，對映後應該會產生A1、A2、B1、B2、C1、C2，但是在產生B2的同時，C1已經產生了，這樣最後的結果就變成A1、A2、B1、C1、C2，B2被捨棄掉了！流程圖如下：
這裡寫圖片描述

以下是flatMap、concatMap和switchMap的執行例項對比：


        //flatMap操作符的執行結果
        Observable.just(10, 20, 30).flatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延遲執行時間為200毫秒、20和30的延遲執行時間為180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;

                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("flatMap Next:" + integer);
            }
        });

        //concatMap操作符的執行結果
        Observable.just(10, 20, 30).concatMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延遲執行時間為200毫秒、20和30的延遲執行時間為180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;

                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("concatMap Next:" + integer);
            }
        });

        //switchMap操作符的執行結果
        Observable.just(10, 20, 30).switchMap(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(Integer integer) {
                //10的延遲執行時間為200毫秒、20和30的延遲執行時間為180毫秒
                int delay = 200;
                if (integer > 10)
                    delay = 180;

                return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("switchMap Next:" + integer);
            }
        });

執行結果如下：
flatMap Next:20
flatMap Next:10
flatMap Next:30
flatMap Next:15
flatMap Next:10
flatMap Next:5

switchMap Next:30
switchMap Next:15

concatMap Next:10
concatMap Next:5
concatMap Next:20
concatMap Next:10
concatMap Next:30
concatMap Next:15

groupBy操作符

groupBy操作符是對源Observable產生的結果進行分組，形成一個型別為GroupedObservable的結果集，GroupedObservable中存在一個方法為getKey()，可以通過該方法獲取結果集的Key值（類似於HashMap的key)。

值得注意的是，由於結果集中的GroupedObservable是把分組結果快取起來，如果對每一個GroupedObservable不進行處理（既不訂閱執行也不對其進行別的操作符運算），就有可能出現記憶體洩露。因此，如果你對某個GroupedObservable不進行處理，最好是對其使用操作符take(0)處理。

groupBy操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.interval(1, TimeUnit.SECONDS).take(10).groupBy(new Func1<Long, Long>() {
            @Override
            public Long call(Long value) {
                //按照key為0,1,2分為3組
                return value % 3;
            }
        }).subscribe(new Action1<GroupedObservable<Long, Long>>() {
            @Override
            public void call(GroupedObservable<Long, Long> result) {
                result.subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long value) {
                        System.out.println("key:" + result.getKey() +", value:" + value);
                    }
                });
            }
        });

執行結果如下：
key:0, value:0
key:1, value:1
key:2, value:2
key:0, value:3
key:1, value:4
key:2, value:5
key:0, value:6
key:1, value:7
key:2, value:8
key:0, value:9

map操作符

map操作符是把源Observable產生的結果，通過對映規則轉換成另一個結果集，並提交給訂閱者進行處理。

map操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1,2,3,4,5,6).map(new Func1<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) {
                //對源Observable產生的結果，都統一乘以3處理
                return integer*3;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println("next:" + integer);
            }
        });

執行結果如下：
next:3
next:6
next:9
next:12
next:15
next:18

cast操作符

cast操作符類似於map操作符，不同的地方在於map操作符可以通過自定義規則，把一個值A1變成另一個值A2，A1和A2的型別可以一樣也可以不一樣；而cast操作符主要是做型別轉換的，傳入引數為型別class，如果源Observable產生的結果不能轉成指定的class，則會丟擲ClassCastException執行時異常。

cast操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

        Observable.just(1,2,3,4,5,6).cast(Integer.class).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer value) {
                System.out.println("next:"+value);
            }
        });

執行結果如下：
next:1
next:2
next:3
next:4
next:5
next:6

scan操作符

scan操作符通過遍歷源Observable產生的結果，依次對每一個結果項按照指定規則進行運算，計算後的結果作為下一個迭代項引數，每一次迭代項都會把計算結果輸出給訂閱者。

scan操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1, 2, 3, 4, 5)
    .scan(new Func2<Integer, Integer, Integer>() {
        @Override
        public Integer call(Integer sum, Integer item) {
            //引數sum就是上一次的計算結果
            return sum + item;
        }
    }).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

執行結果如下：
Next: 1
Next: 3
Next: 6
Next: 10
Next: 15
Sequence complete.

window操作符

window操作符非常類似於buffer操作符，區別在於buffer操作符產生的結果是一個List快取，而window操作符產生的結果是一個Observable，訂閱者可以對這個結果Observable重新進行訂閱處理。

window操作符有很多個過載方法，這裡只舉一個簡單的例子，其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.interval(1, TimeUnit.SECONDS).take(12)
                .window(3, TimeUnit.SECONDS)
                .subscribe(new Action1<Observable<Long>>() {
                    @Override
                    public void call(Observable<Long> observable) {
                        System.out.println("subdivide begin......");
                        observable.subscribe(new Action1<Long>() {
                            @Override
                            public void call(Long aLong) {
                                System.out.println("Next:" + aLong);
                            }
                        });
                    }
                });

執行結果如下：
subdivide begin……
Next:0
Next:1
subdivide begin……
Next:2
Next:3
Next:4
subdivide begin……
Next:5
Next:6
Next:7
subdivide begin……
Next:8
Next:9
Next:10
subdivide begin……
Next:11

Filtering Observables(Observable的過濾操作符)

debounce操作符

debounce操作符對源Observable每產生一個結果後，如果在規定的間隔時間內沒有別的結果產生，則把這個結果提交給訂閱者處理，否則忽略該結果。

值得注意的是，如果源Observable產生的最後一個結果後在規定的時間間隔內呼叫了onCompleted，那麼通過debounce操作符也會把這個結果提交給訂閱者。

debounce操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if(subscriber.isUnsubscribed()) return;
                try {
                    //產生結果的間隔時間分別為100、200、300...900毫秒
                    for (int i = 1; i < 10; i++) {
                        subscriber.onNext(i);
                        Thread.sleep(i * 100);
                    }
                    subscriber.onCompleted();
                }catch(Exception e){
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.newThread())
          .debounce(400, TimeUnit.MILLISECONDS)  //超時時間為400毫秒
          .subscribe(
                new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("Error:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("completed!");
                    }
                });

執行結果如下：
Next:4
Next:5
Next:6
Next:7
Next:8
Next:9
completed!

distinct操作符

distinct操作符對源Observable產生的結果進行過濾，把重複的結果過濾掉，只輸出不重複的結果給訂閱者，非常類似於SQL裡的distinct關鍵字。

distinct操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1, 2, 1, 1, 2, 3)
          .distinct()
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

執行結果如下：
Next: 1
Next: 2
Next: 3
Sequence complete.

elementAt操作符

elementAt操作符在源Observable產生的結果中，僅僅把指定索引的結果提交給訂閱者，索引是從0開始的。其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1,2,3,4,5,6).elementAt(2)
          .subscribe(
                new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println("Next:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("Error:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("completed!");
                    }
                });

執行結果如下：
Next:3
completed!

filter操作符

filter操作符是對源Observable產生的結果按照指定條件進行過濾，只有滿足條件的結果才會提交給訂閱者，其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1, 2, 3, 4, 5)
          .filter(new Func1<Integer, Boolean>() {
              @Override
              public Boolean call(Integer item) {
                return( item < 4 );
              }
          }).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

執行結果如下：
Next: 1
Next: 2
Next: 3
Sequence complete.

ofType操作符

ofType操作符類似於filter操作符，區別在於ofType操作符是按照型別對結果進行過濾，其流程圖如下：
這裡寫圖片描述
呼叫例子如下：

Observable.just(1, "hello world", true, 200L, 0.23f)
          .ofType(Float.class)
          .subscribe(new Subscriber<Object>() {
              @Override
              public void onNext(Object item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Next: 0.23
Sequence complete.

first操作符

first操作符是把源Observable產生的結果的第一個提交給訂閱者，first操作符可以使用elementAt(0)和take(1)替代。其流程圖如下：
這裡寫圖片描述
呼叫例子如下：

        Observable.just(1,2,3,4,5,6,7,8)
          .first()
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Next: 1
Sequence complete.

single操作符

single操作符是對源Observable的結果進行判斷，如果產生的結果滿足指定條件的數量不為1，則丟擲異常，否則把滿足條件的結果提交給訂閱者，其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1,2,3,4,5,6,7,8)
          .single(new Func1<Integer, Boolean>() {
              @Override
              public Boolean call(Integer integer) {
                  //取大於10的第一個數字
                  return integer>10;
              }
          })
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Error: Sequence contains no elements

last操作符

last操作符把源Observable產生的結果的最後一個提交給訂閱者，last操作符可以使用takeLast(1)替代。其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1, 2, 3)
          .last()
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

執行結果如下：
Next: 3
Sequence complete.

ignoreElements操作符

ignoreElements操作符忽略所有源Observable產生的結果，只把Observable的onCompleted和onError事件通知給訂閱者。ignoreElements操作符適用於不太關心Observable產生的結果，只是在Observable結束時(onCompleted)或者出現錯誤時能夠收到通知。

ignoreElements操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

        Observable.just(1,2,3,4,5,6,7,8).ignoreElements()
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Sequence complete.

sample操作符

sample操作符定期掃描源Observable產生的結果，在指定的時間間隔範圍內對源Observable產生的結果進行取樣，其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if(subscriber.isUnsubscribed()) return;
                try {
                    //前8個數字產生的時間間隔為1秒，後一個間隔為3秒
                    for (int i = 1; i < 9; i++) {
                        subscriber.onNext(i);
                        Thread.sleep(1000);
                    }
                    Thread.sleep(2000);
                    subscriber.onNext(9);
                    subscriber.onCompleted();
                } catch(Exception e){
                    subscriber.onError(e);
                }
            }
        }).subscribeOn(Schedulers.newThread())
          .sample(2200, TimeUnit.MILLISECONDS)  //取樣間隔時間為2200毫秒
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Next: 3
Next: 5
Next: 7
Next: 8
Sequence complete.

skip操作符

skip操作符針對源Observable產生的結果，跳過前面n個不進行處理，而把後面的結果提交給訂閱者處理，其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1,2,3,4,5,6,7).skip(3)
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Next: 4
Next: 5
Next: 6
Next: 7
Sequence complete.

skipLast操作符

skipLast操作符針對源Observable產生的結果，忽略Observable最後產生的n個結果，而把前面產生的結果提交給訂閱者處理，

值得注意的是，skipLast操作符提交滿足條件的結果給訂閱者是存在延遲效果的，看以下流程圖即可明白：
這裡寫圖片描述

可以看到skipLast操作符把最後的天藍色球、藍色球、紫色球忽略掉了，但是前面的紅色球等並不是源Observable一產生就直接提交給訂閱者，這裡有一個延遲的效果。

呼叫例子如下：

Observable.just(1,2,3,4,5,6,7).skipLast(3)
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

take操作符

take操作符是把源Observable產生的結果，提取前面的n個提交給訂閱者，而忽略後面的結果，其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1, 2, 3, 4, 5, 6, 7, 8)
          .take(4)
          .subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

執行結果如下：
Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

takeFirst操作符

takeFirst操作符類似於take操作符，同時也類似於first操作符，都是獲取源Observable產生的結果列表中符合指定條件的前一個或多個，與first操作符不同的是，first操作符如果獲取不到資料，則會丟擲NoSuchElementException異常，而takeFirst則會返回一個空的Observable，該Observable只有onCompleted通知而沒有onNext通知。

takeFirst操作符的流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1,2,3,4,5,6,7).takeFirst(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                //獲取數值大於3的資料
                return integer>3;
            }
        })
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Next: 4
Sequence complete.

takeLast操作符

takeLast操作符是把源Observable產生的結果的後n項提交給訂閱者，提交時機是Observable釋出onCompleted通知之時。其流程圖如下：
這裡寫圖片描述

呼叫例子如下：

Observable.just(1,2,3,4,5,6,7).takeLast(2)
          .subscribe(new Subscriber<Integer>() {
              @Override
              public void onNext(Integer item) {
                  System.out.println("Next: " + item);
              }

              @Override
              public void onError(Throwable error) {
                  System.err.println("Error: " + error.getMessage());
              }

              @Override
              public void onCompleted() {
                  System.out.println("Sequence complete.");
              }
          });

執行結果如下：
Next: 6
Next: 7
Sequence complete.

不知不覺介紹了那麼多操作符，篇幅有點長了，下回繼續介紹其他的操作符，敬請期待！

Android RxJava使用介紹（二） RxJava的操作符
2016-04-27
AndroidRxJava
Android RxJava使用介紹（四） RxJava的操作符
2016-04-27
AndroidRxJava
Android RxJava：基礎介紹與使用
2019-03-28
AndroidRxJava
Android RxJava使用介紹（一） Hello World
2016-04-27
AndroidRxJava
RxJava操作符系列三
2016-12-14
RxJava
Rxjava2操作符(三)
2017-12-14
RxJava
RxJava操作符之建立操作符(三)
2017-10-31
RxJava
RxJava常用操作符
2016-09-19
RxJava
RxJava操作符列表
2016-11-26
RxJava
大話RxJava：三、RxJava的中級使用方法
2018-07-02
RxJava
Kotlin 使用Rxjava的compose()操作符
2018-03-05
KotlinRxJava
RxJava 和 RxAndroid 二（操作符的使用）
2016-05-17
RxJavaAndroid
3章 RxJava操作符
2019-05-13
RxJava
RxJava 操作符系列二
2016-12-13
RxJava
RxJava操作符系列一
2016-12-15
RxJava
RxJava操作符系列二
2016-12-15
RxJava
RxJava 操作符系列五
2016-12-18
RxJava
RxJava操作符系列四
2016-12-15
RxJava
RxJava 知識梳理(2) RxJava2 操作符實戰
2017-12-21
RxJava
part05_Rxjava操作符
2018-08-30
RxJava
Rxjava2操作符(二)
2017-12-12
RxJava
詳解Android RxJava的使用
2018-01-01
AndroidRxJava
Rxjava2的簡單使用與基本操作符
2018-02-03
RxJava
一篇不太一樣的RxJava介紹（二）：關於操作符背後的故事
2017-12-11
RxJava
一篇不太一樣的RxJava介紹
2017-12-04
RxJava
RxJava操作符之組合操作符(六)
2019-03-04
RxJava
RxJava操作符之轉換操作符(四)
2017-10-31
RxJava
RxJava操作符之過濾操作符(五)
2017-10-31
RxJava
解剖 RxJava 之變換操作符
2019-02-22
RxJava
RxJava2 操作符總結
2019-01-03
RxJava
RxJava2.0——變換操作符
2020-11-25
RxJava
解剖 RxJava 之過濾操作符
2017-03-27
RxJava
RxJava操作符之Transforming Observables
2016-07-09
RxJavaORM
深入淺出RxJava（2）：操作符
2015-09-15
RxJava
深入淺出RxJava(二：操作符)
2016-06-13
RxJava
Android 淺析 RxJava (一) 使用
2016-03-22
AndroidRxJava
Rxjava2操作符入門(一)
2017-12-08
RxJava
RxJava操作符之Creating Observables
2016-06-23
RxJava

Android RxJava使用介紹（三） RxJava的操作符

Transforming Observables(Observable的轉換操作符)

buffer操作符

flatMap操作符

concatMap操作符

switchMap操作符

groupBy操作符

map操作符

cast操作符

scan操作符

window操作符

Filtering Observables(Observable的過濾操作符)

debounce操作符

distinct操作符

elementAt操作符

filter操作符

ofType操作符

first操作符

single操作符

last操作符

ignoreElements操作符

sample操作符

skip操作符

skipLast操作符

take操作符

takeFirst操作符

takeLast操作符

相關文章