RxJava 學習筆記（五） --- Creating 創建操作符

1. Create —> 使用一個函數從頭創建一個Observable

你可以使用Create操作符從頭開始創建一個Observable，給這個操作符傳遞一個接受觀察者作爲參數的函數，編寫這個函數讓它的行爲表現爲一個Observable–恰當的調用觀察者的onNext，onError和onCompleted方法。

一個形式正確的有限Observable必須嘗試調用觀察者的onCompleted正好一次或者它的onError正好一次，而且此後不能再調用觀察者的任何其它方法。

RxJava將這個操作符實現爲create方法。

建議你在傳遞給create方法的函數中檢查觀察者的isUnsubscribed狀態，以便在沒有觀察者的時候，讓你的Observable停止發射數據或者做昂貴的運算。

示例代碼：

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> observer) {
        try {
            if (!observer.isUnsubscribed()) {
                for (int i = 1; i < 5; i++) {
                    observer.onNext(i);
                }
                observer.onCompleted();
            }
        } catch (Exception e) {
            observer.onError(e);
        }
    }
 } ).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.

create方法默認不在任何特定的調度器上執行。
* Javadoc：create(OnSubscribe)
*

2. Just —> 將一個或多個對象轉換成發射這個或這些對象的一個Observable

創建一個發射指定值的Observable

Just將單個數據轉換爲發射那個數據的Observable。

Just類似於From，但是From會將數組或Iterable的數據取出然後逐個發射，而Just只是簡單的原樣發射，將數組或Iterable當做單個數據。

注意：如果你傳遞null給Just，它會返回一個發射null值的Observable。不要誤認爲它會返回一個空Observable（完全不發射任何數據的Observable），如果需要空Observable你應該使用Empty操作符。

RxJava將這個操作符實現爲just函數，它接受一至九個參數，返回一個按參數列表順序發射這些數據的Observable。

示例代碼：

Observable.just(1, 2, 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
Sequence complete.

Javadoc: just(item)

3. From —> 將一個Iterable, 一個Future, 或者一個數組轉換成一個Observable

將其它種類的對象和數據類型轉換爲Observable

當你使用Observable時，如果你要處理的數據都可以轉換成展現爲Observables，而不是需要混合使用Observables和其它類型的數據，會非常方便。這讓你在數據流的整個生命週期中，可以使用一組統一的操作符來管理它們。

例如，Iterable可以看成是同步的Observable；Future，可以看成是總是隻發射單個數據的Observable。通過顯式地將那些數據轉換爲Observables，你可以像使用Observable一樣與它們交互。

因此，大部分ReactiveX實現都提供了將語言特定的對象和數據結構轉換爲Observables的方法。

在RxJava中，from操作符可以轉換Future、Iterable和數組。對於Iterable和數組，產生的Observable會發射Iterable或數組的每一項數據。

示例代碼

Integer[] items = { 0, 1, 2, 3, 4, 5 };
Observable myObservable = Observable.from(items);

myObservable.subscribe(
    new Action1<Integer>() {
        @Override
        public void call(Integer item) {
            System.out.println(item);
        }
    },
    new Action1<Throwable>() {
        @Override
        public void call(Throwable error) {
            System.out.println("Error encountered: " + error.getMessage());
        }
    },
    new Action0() {
        @Override
        public void call() {
            System.out.println("Sequence complete");
        }
    }
);

輸出

0
1
2
3
4
5
Sequence complete

對於Future，它會發射Future.get()方法返回的單個數據。from方法有一個可接受兩個可選參數的版本，分別指定超時時長和時間單位。如果過了指定的時長Future還沒有返回一個值，這個Observable會發射錯誤通知並終止。

from默認不在任何特定的調度器上執行。然而你可以將Scheduler作爲可選的第二個參數傳遞給Observable，它會在那個調度器上管理這個Future。

4. Defer —> 只有當訂閱者訂閱才創建Observable；爲每個訂閱創建一個新的Observable

直到有觀察者訂閱時才創建Observable，並且爲每個觀察者創建一個新的Observable

Defer操作符會一直等待直到有觀察者訂閱它，然後它使用Observable工廠方法生成一個Observable。它對每個觀察者都這樣做，因此儘管每個訂閱者都以爲自己訂閱的是同一個Observable，事實上每個訂閱者獲取的是它們自己的單獨的數據序列。

在某些情況下，等待直到最後一分鐘（就是知道訂閱發生時）才生成Observable可以確保Observable包含最新的數據。

示例代碼

    str = "你是不是傻";

    Observable<String> just_Observable = Observable.just(str);

    str = "你猜";
    Observable<String> defer_Observable = Observable.defer(new Func0<Observable<String>>() {
        @Override
        public Observable<String> call() {
            return Observable.just(str);
        }
    });

    str = "哈哈";

    just_Observable.subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Log.i("sss",s);
        }
    });

    defer_Observable.subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Log.i("sss",s);
        }
    });

輸出

07-04 15:04:40.582 1699-1699/? I/sss: 你是不是傻
07-04 15:04:40.582 1699-1699/? I/sss: 哈哈

RxJava將這個操作符實現爲 defer方法。這個操作符接受一個你選擇的Observable工廠函數作爲單個參數。這個函數沒有參數，返回一個Observable。

defer方法默認不在任何特定的調度器上執行。
* Javadoc: defer(Func0)

5. Timer —> 創建一個在給定的延時之後發射單個數據的Observable

創建一個Observable，它在一個給定的延遲後發射一個特殊的值。

Timer操作符創建一個在給定的時間段之後返回一個特殊值的Observable。

RxJava將這個操作符實現爲timer函數。

timer返回一個Observable，它在延遲一段給定的時間後發射一個簡單的數字0。

timer操作符默認在computation調度器上執行。有一個變體可以通過可選參數指定Scheduler。

示例代碼

Observable.timer(3,TimeUnit.SECONDS)
    .subscribe(new Observer<Long>() {

        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Long number) {
            Log.d("RXJAVA", "I say " + number);
        }
    });

輸出

它將`3`秒後發射`0`,然後就完成了

每隔一段時間就產生一個數字，沒有結束符，也就是是可以產生無限個連續的數字(但是這個已經不建議使用了，廢棄掉了，因爲一個名叫interval的操作符有同樣的功能。)

示例代碼

Observable.timer(3,3,TimeUnit.SECONDS)
    .subscribe(new Observer<Long>() {

        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Long number) {
            Log.d("RXJAVA", "I say " + number);
        }
    });

輸出

每隔`3`秒產生一個數字

I say 0
I say 1
I say 2
I say 3
...

Javadoc：timer(long,TimeUnit)
Javadoc：timer(long,TimeUnit,Scheduler)

6. Interval —> 創建一個按照給定的時間間隔發射整數序列的Observable

Interval操作符返回一個Observable，它按固定的時間間隔發射一個無限遞增的整數序列。

它接受一個表示時間間隔的參數和一個表示時間單位的參數

Javadoc：interval(long,TimeUnit)
Javadoc：interval(long,TimeUnit,Scheduler)

7. Range —> 創建一個發射指定範圍的整數序列的Observable

range操作符是創建一組在從n開始，個數爲m的連續數字，比如range(3,10)，就是創建3、4、5…12的一組數字

示例代碼

Observable.range(3,10).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

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

            @Override
            public void onNext(Integer i) {
                System.out.println("Next:" + i.toString());
            }
        });

輸出

Next:3 
Next:4 
Next:5 
Next:6 
...
Next:12 
Sequence complete.

range默認不在任何特定的調度器上執行。有一個變體可以通過可選參數指定Scheduler。

Javadoc: range(int,int)
Javadoc: range(int,int,Scheduler)

8. Repeat —> 創建一個重複發射指定數據或數據序列的Observable

Repeat重複地發射數據。某些實現允許你重複的發射某個數據序列，還有一些允許你限制重複的次數。

RxJava將這個操作符實現爲repeat方法。它不是創建一個Observable，而是重複發射原始Observable的數據序列，這個序列或者是無限的，或者通過repeat(n)指定重複次數。

repeat操作符默認在trampoline調度器上執行。有一個變體可以通過可選參數指定Scheduler。

示例代碼

Observable.range(3,2).repeat(3).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.i("sss",integer+" ");
            }
        });

輸出

 I/sss: 3 
 I/sss: 4 
 I/sss: 3 
 I/sss: 4 
 I/sss: 3 
 I/sss: 4

Javadoc：repeat()
Javadoc：repeat(long)
Javadoc：repeat(Scheduler)
Javadoc：repeat(long,Scheduler)

9. RepeatWhen —> 有條件的重新訂閱和發射原來的Observable。

將原始Observable的終止通知（完成或錯誤）當做一個void數據傳遞給一個通知處理器，它以此來決定是否要重新訂閱和發射原來的Observable。這個通知處理器就像一個Observable操作符，接受一個發射void通知的Observable爲輸入，返回一個發射void數據（意思是，重新訂閱和發射原始Observable）或者直接終止（意思是，使用repeatWhen終止發射數據）的Observable。

示例代碼

Observable.just(1,2,3,4).repeatWhen(new Func1<Observable<? extends Void>, Observable<?>>() {
            @Override
            public Observable<?> call(Observable<? extends Void> observable) {
                // 延遲1秒
                return Observable.timer(1,TimeUnit.SECONDS);
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println(""+integer);
            }
        });

輸出

I/System.out: 1
I/System.out: 2
I/System.out: 3
I/System.out: 4
I/System.out: 1
I/System.out: 2
I/System.out: 3
I/System.out: 4

repeatWhen操作符默認在trampoline調度器上執行。有一個變體可以通過可選參數指定Scheduler。

Javadoc：repeatWhen(Func1)
Javadoc：repeatWhen(Func1,Scheduler)

參考：
http://rxjava.yuxingxin.com/chapter5/the_map_family.html
https://github.com/mcxiaoke/RxDocs
https://www.gitbook.com/book/mcxiaoke/rxdocs

李樟清

發佈了34 篇原創文章 · 獲贊 8 · 訪問量 3萬+

私信關注

RxJava 學習筆記（五） --- Creating 創建操作符

1. Create —> 使用一個函數從頭創建一個Observable

2. Just —> 將一個或多個對象轉換成發射這個或這些對象的一個Observable

3. From —> 將一個Iterable, 一個Future, 或者一個數組轉換成一個Observable

4. Defer —> 只有當訂閱者訂閱才創建Observable；爲每個訂閱創建一個新的Observable

5. Timer —> 創建一個在給定的延時之後發射單個數據的Observable

6. Interval —> 創建一個按照給定的時間間隔發射整數序列的Observable

7. Range —> 創建一個發射指定範圍的整數序列的Observable

8. Repeat —> 創建一個重複發射指定數據或數據序列的Observable

9. RepeatWhen —> 有條件的重新訂閱和發射原來的Observable。

RxJava 學習筆記（一）

RxJava 學習筆記（八） --- Combining 結合操作

RxJava 學習筆記（九） --- Error Handling 錯誤處理操作

如何使用MarkDown 使代碼塊高亮

JNI 學習筆記（一）-- JNI函數調用流程，JNI理解和基本數據類型

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結