前言：陽光總在風雨後，人生沒有白吃的苦，也沒有白走的路，要知道，你現在吃的苦，現在受的傷，會成為日後的徽章。

一、概述

提高開發效果，降低維護成本一直是團隊追求的宗旨。現在安卓裡面RxJava2+Retrofit+OKHttp的網絡請求架構是最流行的，幾乎一統江湖，配合響應式式程式設計的RxJava使用也越來越多。如果英文比較好而且有興趣的可以到官網學習：ReactiveX的官方網站。（源碼和其他相關連結在文章最後給出）

RxJava到底是什麼？

RxJava在GitHub上《RxJava》的自我介紹是：a library for composing asynchronous and event-based programs using observable sequences for the Java VM.(一個在Java VM 上使用可觀測的序列來組成異步的，基于事件的程式的庫)，有些人可能感到疑惑，其實本質上可以用一詞來概括——“異步”，它就是一個異步的操作庫，而别的定語都基于這之上。

RxJava的好處是啥？

同樣是異步操作，為什麼不用Handler或者AsyncTask等異步機制？

因為：簡潔

異步操作很關鍵的一點是簡潔性，因為在排程過程比較複雜的情況下，異步代碼既難寫也難讀懂。Android創造的Handler和AsyncTask其實都是為了讓異步代碼更加簡潔，RxJava的優勢也是簡潔，它的特别之處是：随着程式代碼邏輯的變得越來越複雜，它依然保持簡潔。

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

二、使用詳解

1.基本實作

RxJava最核心的兩個東西Observable（被觀察者、事件源）和Observer（觀察者），Observable發出一系列的事件，Observer處理這些事件。在Observer接收到事件處理之前我們很友善地對結果做出各種攔截處理等。

RxJava的流程圖大緻如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

1).添加依賴庫

在model的build.gradle檔案内添加RxJava2依賴庫，注意RxJava1與RxJava2依賴不能共存。

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

implementation 'io.reactivex.rxjava2:rxjava:2.0.4'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

2).三步建立執行個體

//1、建立被觀察者Observable
    Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            e.onNext("RxJava：e.onNext== 第一次");
            e.onNext("RxJava：e.onNext== 第二次");
            e.onNext("RxJava：e.onNext== 第三次");
            e.onComplete();
        }
    });

    //2、建立觀察者Observer
    Observer<String> observer = new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onSubscribe == 訂閱");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext == " + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete == ");
        }
    };

    //3、訂閱(觀察者觀察被觀察者)
    observable.subscribe(observer);

直接運作上面的例子，列印結果如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

上述例子中，通過new Observer<T>()建立觀察者，實作相應的方法，Observable.create(ObservableOnSubscribe)建立被觀察者，subscribe()将兩者關聯起來。

3).觀察者模式

RxJava的異步實作，是通過一種拓展的觀察者模式來實作的。

什麼是觀察者模式？

其實就是釋出訂閱模式，釋出者釋出資訊，訂閱者接受資訊。沒訂閱就接收不到資訊。

觀察者模式面向的需求是:A對象(觀察者)對B對象(被觀察者)的某種變化高度敏感，需要在B對象變化的一瞬間做出變化。程式的觀察者模式，觀察者不需要時刻盯着被觀察者，而是采用注冊(Regsiter)或者訂閱(Subscribe)的方式，告訴被觀察者，我是你的某種狀态，你的狀态在發生變化的時候來通知我。

例如：連載小說和讀者的關系，觀察者是讀者，被觀察者是連載小說，讀者訂閱了連載小說，當連載小說釋出新的章節時通知并推送給讀者，然後讀者閱讀新的章節，這就是觀察者模式。

RxJava的觀察者模式

RxJava有四個基本概念：Observer(觀察者)，Observable(被觀察者)，subscribe(訂閱)，事件。Observer和Observable通過subscribe()實作訂閱關系，進而Observable可以在需要的時候發出事件通知Observer。

Observer：觀察者，它決定事件發生時有怎麼樣的行為；
Observable：被觀察者，它決定什麼時候出發事件以及觸發什麼樣的事件；
subscribe：訂閱，将Observer和Observable關聯起來。

我們來看看上面的例子的具體步驟：

1）建立被觀察者Observable

它決定什麼時候出發事件以及觸發怎麼樣的事件，通過Observable.create(ObservableOnSubscribe)建立被觀察者執行個體，這是最基本的創造事件序列的方法，并為它定義事件出發規則。

//建立被觀察者Observable
    Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            e.onNext("RxJava：e.onNext== 第一次");
            e.onNext("RxJava：e.onNext== 第二次");
            e.onNext("RxJava：e.onNext== 第三次");
            e.onComplete();
        }
    });

建立一個ObservableOnSubscribe對象并且實作subscribe()方法，設定了事件的内容是String，并傳回ObservableEmitter，相當于一個計劃表，當Observable被訂閱的時候，複寫subscribe()方法定義發送的事件，ObservableEmitter是事件發射器，定義并且觀向察者發送需要發送的事件，onNext()會被執行三次，最後執行onComplete()方法，這樣由被觀察者調用觀察者回調的方法，實作了被觀察者向觀察者傳遞事件。

2）建立觀察者Observer

它決定事件觸發有怎樣的行為，定義響應事件的行為，直接new一個Observer觀察者執行個體，實作其中相應的方法：

//建立觀察者Observer
    Observer<String> observer = new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onSubscribe == 訂閱");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext == " + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete == ");
        }
    };

onSubscribe(Disposable d)：事件訂閱成功回調，傳回Disposable請求執行個體，可以通過d.dispose()取消請求；
onNext(T)：響應事件的方法，發送事件時，觀察者會回調onNext()方法，接收事件資料；
onError()：事件隊列異常，在處理事件出現異常的時候回觸發這個方法，其他事件不會再繼續發出；
onComplete()：事件隊列完結，當不再有新onNext()發出時，需要觸發onComplete()方法來作為标志，其他事件不會再繼續發出

在一個正确的事件運作隊列中，onError()和onComplete()有且僅有一個出現，還是在事件的最後出現，即onError()和onComplete()是互斥的，當一個出現了，另一個就不再回出現。

3）subscribe()

訂閱，連接配接Observable(被觀察者)和Observer(觀察者)。

//訂閱(觀察者觀察被觀察者)
    observable.subscribe(observer);

Observable是被觀察者，observer是觀察者，建立完Observer和Observable之後，通過subscribe()将兩者關聯起來。

通過該調用，回調觀察者的相關方法，進而響應被觀察者響應的事件，Observable隻生産事件，真正發送事件的是在它訂閱的時候，即subscribe()被調用的時候。

另外：觀察者Obaserver的subscribe具有多個重載的方法：

//觀察者不對被觀察者發送的事件做出響應(但是被觀察者還可以繼續發送事件)
    public final Disposable subscribe()

    //觀察者對被觀察者發送的任何事件都做出響應
    public final void subscribe(Observer<? super T> observer)

    //表示觀察者隻對被觀察者發送的Next事件做出響應
    public final Disposable subscribe(Consumer<? super T> onNext)

    //表示觀察者隻對被觀察者發送的Next & Error事件做出響應
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)

    //表示觀察者隻對被觀察者發送的Next & Error & Complete事件做出響應
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
                                      Action onComplete)

    //表示觀察者隻對被觀察者發送的Next & Error & Complete & onSubscribe事件做出響應
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
                                      Action onComplete, Consumer<? super Disposable> onSubscribe)

2.Scheduler排程者

在RxJava預設規則中，事件的發出和消費都是在同一個線程中發生的，那麼上面的例子來說，就是一個同步的觀察者模式。觀察者模式的本省就是背景處理，前台回調的異步機制，是以異步對RxJava來說是至關重要的，異步的實作則需要用到Scheduler排程器來切換線程。

在RxJava中Scheduler(排程器)相當于線程控制器，RxJava通過Scheduler來指定那一部分代碼執行在哪一個線程。我們來看看簡單的例子：

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> e) throws Exception {
            e.onNext("RxJava：e.onNext== 第一次");       
            e.onComplete();
            Log.d(TAG, "subscribe()線程==" + Thread.currentThread().getId());
        }
    }).subscribeOn(Schedulers.io())//指定被觀察者subscribe()(發送事件的線程)在IO線程()
            .observeOn(AndroidSchedulers.mainThread());//指定觀察者接收響應事件的線程在主線程

log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

可以看到主線程id為1，執行事件subscribe()方法的線程id為432，回調事件方法onNext()的線程為1，即在主線程中執行。

由于subscribeOn(Schedulers.io())指定了subscribe()方法發送事件線程在IO線程中執行，observeOn(AndroidSchedulers.mainThread())指定了接收事件在主線程中執行。這種方式非常常見，适用于背景擷取資料，前台顯示的程式政策。

subscribeOn()：用于指定Observable被觀察者subscribe()時所發生的線程，即指定發生事件的線程
observeOn()：指定 Observer觀察者接收&響應事件的線程，即訂閱者接收事件的線程

注意：多次指定發射事件的線程隻有第一次指定有效，也就是說多次調用subscribeOn()隻有第一次有效，其餘的會被忽略；但是多次指定訂閱者接收事件的線程是可以的，也就是說每observeOn()一次，接收事件的線程就會切換一次。

RxJava中内置了很多線程項供我們選擇：

Schedulers.io()：代表IO操作的線程，通常用于網絡、讀寫檔案等IO密集型的操作。行為模式和new Thread()差不多，隻是IO的内部是一個無上限的線程池，可重用空閑的線程，更高效（不要把計算工作放在IO内，可以避免建立不必要的線程）；
AndroidSchedulers.mainThread()：Android的主線程；用于更新UI
Schedulers.newThread()：總是啟用新線程，并在新線程中執行操作；多用于耗時操作
Schedulers.computation()：代表CPU計算密集型的操作，即不會被IO等操作限制性能的操作。

三、常用操作方式

RxJava的強大之處，在于它提供類豐富且強悍的操作符，通過使用群組合操作符，你幾乎能完成你想完成的任務。下面我們來了解這些操作符的含義和使用方法。

1.快速建立

（1）create()：是所有建立型操作符的“根”，也就是說其他建立型操作符最後都是通過create()來建立的Observable的，快速建立被觀察者對象，僅發送onComplete()事件，直接通知完成。

Observable.create(new ObservableOnSubscribe<String>() {
        @Override
        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
            try{
                if (!emitter.isDisposed()){
                    emitter.onNext("RxJava：e.onNext== 第一次");
                    emitter.onNext("RxJava：e.onNext== 第二次");
                    emitter.onNext("RxJava：e.onNext== 第三次");
                    emitter.onComplete();
                }
            }catch (Exception e){
                emitter.onError(e);
            }
        }
    }).subscribe(new Observer<String>() {
        //預設最先複寫onSubscribe()
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "onSubscribe == 訂閱");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "onNext == " + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "onComplete == ");
        }
    });

在使用create()操作符時，最好在被觀察者的回調函數subscribe()中加上isDisposed()，以便在觀察者斷開連接配接的時候不在執行subscribe()函數中的相關邏輯，避免意想不到的錯誤出現。

列印資料如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（2）empty()：快速建立被觀察者對象，僅發送onComplete()事件，直接通知完成。

//快速建立被觀察者對象，僅發送onComplete()事件，直接通知完成。
Observable.empty()
           .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "empty：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Object o) {
            Log.e(TAG, "empty：onNext ==" + o.toString());
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "empty：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "empty：onComplete == ");
        }
    });

列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（3）error()：快速建立被觀察者對象，僅發送onError()事件，直接通知異常。

//快速建立被觀察者對象，僅發送onError()事件，直接通知異常。
    Observable.error(new Throwable("隻回調error"))
            .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "error：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Object o) {
            Log.e(TAG, "error：onNext ==" + o.toString());
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "error：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "error：onComplete == ");
        }
    });

列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（4）never()：快速建立被觀察者對象，不發送任何事件。

//快速建立被觀察者對象，不發送任何事件。
    Observable.never()
              .subscribe(new Observer<Object>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "never：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Object o) {
            Log.e(TAG, "never：onNext ==" + o.toString());
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "never：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "never：onComplete == ");
        }
    });

列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（5）Just(T... items)：快速建立被觀察者對象，最多隻能發送10個事件。

參數類型：任意類型

Observable.just(1, 2, 3, 4, 5).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "just：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Integer integer) {
            Log.e(TAG, "just：onNext == " + integer);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "just：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "just：onComplete == ");
        }
    });

通過just()建立傳入Integer類型的參數建構Observable被觀察者，相當于執行了onNext(1)~onNext(5)，通過鍊式程式設計訂閱觀察者。log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（6）fromArray(T... items)：快速建立被觀察者對象，可發送多個任意子類型的資料。

參數類型：數組，子類型可以為任意類型

//設定需要傳入的數組
    String[] strings = {"商品類","非商品類"};
    //傳入數組，被觀察者建立後會将數組轉換成Observable并且發送裡面是以的資料
    Observable.fromArray(strings).subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "fromArray：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(String s) {
            Log.e(TAG, "fromArray：onNext == " + s);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "fromArray：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "fromArray：onComplete == ");
        }
    });

通過fromArray()建立被觀察者對象，傳入數組，被觀察者建立後會将數組轉換成Observable(被觀察者)并且發送裡面所有的資料。列印資料如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（7）fromIterable(Iterable<? extends T> source)：快速建立被觀察者對象，可發送多個任意子類型的資料。

參數類型：集合，子類型可以為任意類型

//建立集合
    List<Goods> list = new ArrayList();
                for (int i = 0; i < 3; i++) {
        Goods g = new Goods("名稱" + i);
        list.add(g);
    }
    //傳入集合，被觀察者建立後會将數組轉換成Observable并且發送裡面所有的資料
                Observable.fromIterable(list).subscribe(new Observer<Goods>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "fromArray：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Goods goods) {
            Log.e(TAG, "fromArray：onNext == " + goods.getName());
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "fromArray：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "fromArray：onComplete == ");
        }
    });

通過fromIterable()建立被觀察者Observable對象，傳入集合，被觀察者建立後會将數組轉換成Observable(被觀察者)并且發送裡面所有的資料。列印資料如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

2.延遲建立

（1）defer()：直到有Observer觀察者訂閱時，才會通過Observeable的工廠方法動态建立Observeable，并且發送事件

每次訂閱後都會得到一個剛建立的最新的Observable對象，確定被觀察者對象的資料是最新的。

//1.初始化i
    Integer i = 100;
    //2.通過defer()定義被觀察者（此時被觀察者對象還沒建立）
    Observable<Integer> defer = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
        @Override
        public ObservableSource<? extends Integer> call() throws Exception {
            return Observable.just(i);
        }
    });

    //3.重新設定i值
    i = 200;

    //4.訂閱觀察者（此時才會調用defer,建立被觀察者對象）
        defer.subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "defer：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Integer i) {
            Log.e(TAG, "defer：onNext == " + i);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "defer：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "defer：onComplete == ");
        }
    });

在訂閱的時候才開始建立被觀察者對象，然後再發送事件，是以i的值是最新的資料 i = 200；列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（2）timer()：快速建立Observable被觀察者對象，延遲指定時間後發送一個類型為Long的事件

構造方法：

timer(long delay, TimeUnit unit)
 timer(long delay, TimeUnit unit, Scheduler scheduler)

delay：延時的時間，類型為Long；
unit：表示時間機關，有TimeUnit.SECONDS等多種類型；
scheduler：表示排程器，用于指定線程。

發送的事件類型為Long，數值為0，相當于onNext(0);

final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    Log.e(TAG, "timer：目前時間 ==" + dateFormat.format(System.currentTimeMillis()));
    //延時10秒後，發送一個long值為0的事件
    Observable.timer(3, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "timer：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "timer：onNext ==" + aLong + "   時間 ==" + dateFormat.format(System.currentTimeMillis()));
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "timer：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "timer：onComplete == ");
        }
    });

延時3秒後，發送一個long值為0的事件，約3秒後響應事件onNext()接收到資料，另外，timer預設運作在一個新的線程上，也可以自定義線程排程器scheduler。列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（3）interval()：快速建立Observable被觀察者對象，每隔指定的時間就發送相應的事件，事件序列從0開始，無限遞增1；

構造方法：

//在指定延遲時間後，每個多少時間發送一次事件
interval(long initialDelay, long period, TimeUnit unit)

//在指定的延遲時間後，每隔多少時間發送一次事件，可以指定排程器
interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler)

//每間隔多少時間發送一次事件，使用預設的線程
Observable<Long> interval(long period, TimeUnit unit)

//每間隔多少時間發送一次事件，可以指定排程器
interval(long period, TimeUnit unit, Scheduler scheduler)

initialDelay：表示延遲開始的時間，類型為Long；
period：距離下一次發送事件的時間間隔，類型為Long；
unit：時間機關，有TimeUnit.SECONDS等多種類型；
scheduler：表示排程器，用于指定線程。

interval()提供了多種構造方法選擇，每隔一定的時間period就發送一次事件，事件資料從0開始，無限增加1。

//initialDelay：表示延遲開始的時間, period：距離下一次發送事件的時間間隔, unit：時間機關    
 Observable.interval(3, 1, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "interval：onSubscribe == 訂閱");
        }

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

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "interval：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "interval：onComplete == ");
        }
    });

上述列子延遲3秒後開始發送事件，每次發送事件的時間間隔為1秒，無限發送，時間機關設定為秒，這種情景我們可以用來設定定時器等相關操作，列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（4）intervalRange()：類似于interval()，快速建立一個被觀察者對象，指定時間間隔就發送事件，可以執行發送事件的數量，資料依次遞增1。

構造方法：

intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)

intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)

start：表示事件開始的數值大小，類型為Long；
count：表示事件執行的次數，類型為long，不能為負數;
initialDelay：表示延遲開始的時間，類型為Long；
period：距離下一次發送事件的時間間隔，類型為Long；
unit：時間機關，有TimeUnit.SECONDS等多種類型；
scheduler：表示排程器，用于指定線程。

注意：count不能為負數，否則會抛出異常，我将count設定為-1，運作報錯如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

//事件開始大小為10，發送5次事件，延遲3秒後執行，每次執行的間隔為1，機關為秒
Observable.intervalRange(10, 5, 3, 1, TimeUnit.SECONDS)
            .subscribe(new Observer<Long>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "intervalRange：onSubscribe == 訂閱");
        }

        @Override
        public void onNext(Long aLong) {
            Log.e(TAG, "intervalRange：onNext ==" + aLong);
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "intervalRange：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "intervalRange：onComplete == ");
        }
    });

這裡指定了事件開始大小為10，發送5次事件，延遲3秒後執行，每次執行的間隔為1，機關為秒，列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

（5）range(final int start, final int count)：類似于intervalRange()，快速建立一個被觀察者對象，指定事件起始值，執行發送事件的數量，但是差別在于range()不能延遲發送的時間。

注意：上述參數的類型是int類型，rangeLong(long start, long count)隻是參數類型不同，用法一緻。

//start：事件的開始值大小，count：發送的事件次數
Observable.range(5, 4).subscribe(new Observer<Integer>() {
        @Override
        public void onSubscribe(Disposable d) {
            Log.e(TAG, "range：onSubscribe == 訂閱");
        }

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

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "range：onError == " + e.getMessage());
        }

        @Override
        public void onComplete() {
            Log.e(TAG, "range：onComplete == ");
        }
    });

這裡指定了事件的開始值大小為5，發送的事件數為4次，一次遞增1；列印log如下：

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

上述的幾種常用的建立操作符總結一下：

建立類型	作用	備注	使用場景
基本建立	create()	建立一個完成的被觀察者(Observable)	RxJava中建立被觀察者最基本的操作符	1、完整&快速建立被觀察者 2、數組、集合周遊
快速建立	empty()	快速建立後隻發送complete事件，直接通知完成
error()	快速建立後隻發送error事件，直接通知異常
never()	快速建立後不發送任何事件
just()	快速建立後直接發送傳入的事件	參數最多隻能10個，即發送的事件最多10個
fromArray()	快速建立後直接發送傳入的數組資料	參數為數組，子類型為任意類型，可10個以上
fromIterable()	快速建立後直接發送傳入的集合List資料	參數為集合List，子類型為任意類型，可10個以上
延時建立	defer()	直到觀察者Observer訂閱被觀察者Observable時，才動态建立被觀察者&發送事件	通過Observable工廠方法建立被觀察者，每次訂閱後都會得到一個最新建立的被觀察者Observable，確定裡面的資料是最新的	1、定時操作 2、周期性操作
timer()	快速建立被觀察者，指定延時時間，發送一個數值為0的事件	延時指定時間後發送一個參數為0的事件，相當于onNext（0）
interval()	快速建立被觀察者，每隔指定時間發送事件	發送事件序列，從0開始，無限遞增1
intervalRange()	快速建立被觀察者，每隔指定時間發送事件，可指定發送事件數	發送無限遞增1的事件序列，可指定起始值大小和事件次數，可延時，類似interval()
range()	快速建立被觀察者，連續發送一個時間序列，可指定範圍	發送無限遞增1的事件序列，可指定起始值大小和事件次數，不可延時，類似intervalRange()
rangeLong()	同上，差別在于資料參數為類型Long	同上

本來想一篇寫完的，但是考慮到篇幅太長影響閱讀的效率，是以還是另外再開一篇來講解其他的用法，想繼續了解的可以點選RxJava2最全面、最詳細的用法講解（二）。

源碼位址：https://github.com/FollowExcellence/Rxjava_Retrofit

點關注，不迷路

好了各位，以上就是這篇文章的全部内容了，能看到這裡的人呀，都是人才。

我是suming，感謝各位的支援和認可，您的點贊、評論、收藏【一鍵三連】就是我創作的最大動力，我們下篇文章見！

如果本篇部落格有任何錯誤，請批評指教，不勝感激！

要想成為一個優秀的安卓開發者，這裡有必須要掌握的知識架構，一步一步朝着自己的夢想前進！Keep Moving!

相關文章：

Retrofit2詳解和使用（一）

Retrofit2的介紹和簡單使用

OKHttp3的使用和詳解

OKHttp3的用法介紹和解析

OKHttp3源碼詳解

從源碼角度解釋OKHttp3的關鍵流程和重要操作

RxJava2詳解（一）

詳細介紹了RxJava的使用（基本建立、快速建立、延遲建立等操作符）

RxJava2詳解（二）

RxJava轉換、組合、合并等操作符的使用

RxJava2詳解（三）

RxJava延遲、do相關、錯誤處理等操作符的使用

RxJava2詳解（四）

RxJava過濾、其他操作符的使用

上述幾篇都是android開發必須掌握的，後續會完善其他部分！

RxJava2最全面、最詳細的講解（一）一、概述二、使用詳解三、常用操作方式

一、概述

RxJava到底是什麼？

RxJava的好處是啥？

二、使用詳解

1.基本實作

什麼是觀察者模式？

RxJava的觀察者模式

2.Scheduler排程者

三、常用操作方式

1.快速建立

2.延遲建立

點關注，不迷路

繼續閱讀

RxJava學習筆記之Subscription

DispatchMessage - synchronous or asynchronous

解決QPropertyAnimation動畫小bug

libevent異步TCP連接配接，判斷是否連接配接成功

深入淺出異步I/O模型

Linux裝置驅動之阻塞I/O與異步通知

信号量，等待隊列，異步通知，驅動例子

網絡同步與異步概念整理

同步(Synchronous)/異步(Asynchronous)

同步與異步的差別，同步函數與異步函數的差別同步與異步的差別同步函數和異步函數的差別

異步與同步的差別

同步、異步

iOS上的http請求：get、post以及同步、異步

WebWorker 100%前端基礎應用

ES6-----Promise 對象

setState詳解