RxJava操作符－創建型

操作符類型

創建操作
變換操作
過濾操作
組合操作
錯誤處理
輔助操作
條件和布爾操作
算術和聚合操作
連接操作
轉換操作

創建操作

`create`

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

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

create操作符是所有創建型操作符的“根”，也就是說其他創建型操作符最後都是通過create操作符來創建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操作符時，最好要在回調的call函數中增加isUnsubscribed的判斷，以便在subscriber在取消訂閱時不會再執行call函數中相關代碼邏輯，從而避免導致一些意想不到的錯誤出現。

`from`

將其它種類(只侷限於Future、Iterable和數組？)的對象和數據類型轉換爲Observable。

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

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

from(array)
from(Iterable)
from(Future)
from(Future,Scheduler)
from(Future,timeout, timeUnit)

其流程圖例如下：

示例代碼

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

`just`

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

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

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

它接受一至九個參數，返回一個按參數列表順序發射這些數據的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.

`defer`

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

defer操作符能夠保證Observable的狀態是最新的。

這個操作符接受一個你選擇的Observable工廠函數作爲單個參數。這個函數沒有參數，返回一個Observable。

defer(Func0)

defer方法默認不在任何特定的調度器上執行。

其流程圖例如下：

defer操作符和just操作符運行結果比較示例程序

i=10;
        Observable justObservable = Observable.just(i);
        i=12;
        Observable deferObservable = Observable.defer(new Func0<Observable<Object>>() {
            @Override
            public Observable<Object> call() {
                return Observable.just(i);
            }
        });
        i=15;

        justObservable.subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {
                System.out.println("just result:" + o.toString());
            }
        });

        deferObservable.subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {
                System.out.println("defer result:" + o.toString());
            }
        });

運行結果如下：
just result:10
defer result:15

可以看到，just操作符是在創建Observable就進行了賦值操作，而defer是在訂閱者訂閱時才創建Observable，此時才進行真正的賦值操作。

`timer`

注：該操作符已經不建議使用了，因爲一個名叫interval的操作符有同樣的功能。

timer操作符創建定時發送數字的Observable，這裏有兩種情況：

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

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

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

timer(long,TimeUnit)
timer(long,TimeUnit,Scheduler)

其流程實例如下：

創建一個Observable，每隔一段時間就產生一個數字，沒有結束符，也就是是可以產生無限個連續的數字

timer(long,long,TimeUnit)

其流程實例如下：

示例程序

//每隔兩秒產生一個數字
        Observable.timer(2, 2, TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
            @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(Long aLong) {
                System.out.println("Next:" + aLong.toString());
            }
        });

運行結果如下：
Next:0
Next:1
Next:2
Next:3
……

`interval`

創建一個按固定時間間隔發射整數序列的Observable，它按固定的時間間隔發射一個無限遞增的整數序列。這些數字從0開始，一次遞增1直至無窮大。

interval(long,TimeUnit)
interval(long,TimeUnit,Scheduler)
interval(long,long,TimeUnit))
interval(long,long,TimeUnit,Scheduler)

interval默認在computation調度器上執行。你也可以傳遞一個可選的Scheduler參數來指定調度器。

其流程實例如下：

示例程序：interval操作符的實現效果跟上面的timer操作符的第二種情形一樣。

`range`

創建一個發射特定整數序列的Observable，其發射一個範圍內的有序整數序列，你可以指定範圍的起始和長度。

它接受兩個參數，一個是範圍的起始值，一個是範圍的數據的數目。如果你將第二個參數設爲0，將導致Observable不發射任何數據（如果設置爲負數，會拋異常）。

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

range(int,int)
range(int,int,Scheduler)

其流程實例如下：

示例程序

//產生從3開始，個數爲10個的連續數字
        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.

`repeat/repeatWhen`

`repeat`

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

它不是創建一個Observable，而是重複發射原始Observable的數據序列，發射次數或者是無限的，或者通過repeat(n)指定重複次數。

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

repeat()
repeat(long))
repeat(Scheduler))
repeat(long,Scheduler)

其流程實例如下：

示例程序

//連續產生兩組(3,4,5)的數字
        Observable.range(3,3).repeat(2).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:3
Next:4
Next:5
Sequence complete.

`repeatWhen`

它不是緩存和重放原始Observable的數據序列，而是有條件的重新訂閱和發射原來的Observable。

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

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

repeatWhen(Func1)
repeatWhen(Func1,Scheduler)

其流程實例如下：

示例程序

Observable.just(1,2,3).repeatWhen(new Func1<Observable<? extends Void>, Observable<?>>() {
            @Override
            public Observable<?> call(Observable<? extends Void> observable) {
                //重複3次
                return observable.zipWith(Observable.range(1, 3), new Func2<Void, Integer, Integer>() {
                    @Override
                    public Integer call(Void aVoid, Integer integer) {
                        return integer;
                    }
                }).flatMap(new Func1<Integer, Observable<?>>() {
                    @Override
                    public Observable<?> call(Integer integer) {
                        System.out.println("delay repeat the " + integer + " count");
                        //1秒鐘重複一次
                        return Observable.timer(1, TimeUnit.SECONDS);
                    }
                });
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

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

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

運行結果如下：
Next:1
Next:2
Next:3
repeat the 1 count
Next:1
Next:2
Next:3
repeat the 2 count
Next:1
Next:2
Next:3
repeat the 3 count
Next:1
Next:2
Next:3
Sequence complete.

`empty/never/error`

這些操作符默認不在任何特定的調度器上執行，但是empty和error有一個可選參數是Scheduler，如果你傳遞了Scheduler參數，它們會在這個調度器上發送通知。

`empty`

創建一個不發射任何數據但是正常終止的Observable。
empty()

`never`

創建一個不發射數據也不終止的Observable。
never()

`error`

創建一個不發射數據以一個錯誤終止的Observable。
error(java.lang.Throwable)

參考文章鏈接

RxJava操作符 －創建型

操作符類型

創建操作

create

示例代碼

from

示例代碼

just

示例代碼

defer

defer操作符和just操作符運行結果比較示例程序

timer

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

創建一個Observable，每隔一段時間就產生一個數字，沒有結束符，也就是是可以產生無限個連續的數字

示例程序

interval

range

示例程序

repeat/repeatWhen

repeat

示例程序

repeatWhen

示例程序

empty/never/error

empty

never

error

RxJava操作符－創建型

`create`

`from`

`just`

`defer`

`timer`

`interval`

`range`

`repeat/repeatWhen`

`repeat`

`repeatWhen`

`empty/never/error`

`empty`

`never`

`error`