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

一、概述

提高開發效果，降低維護成本一直是團隊追求的宗旨。現在安卓裏面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的優勢也是簡潔，它的特別之處是：隨着程序代碼邏輯的變得越來越複雜，它依然保持簡潔。

二、使用詳解

1.基本實現

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

RxJava的流程圖大致如下：

1).添加依賴庫

在model的build.gradle文件內添加RxJava2依賴庫，注意RxJava1與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);

直接運行上面的例子，打印結果如下：

上述例子中，通過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如下：

可以看到主線程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()函數中的相關邏輯，避免意想不到的錯誤出現。

打印數據如下：

（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如下：

（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如下：

（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如下：

（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如下：

（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(被觀察者)並且發送裏面所有的數據。打印數據如下：

（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(被觀察者)並且發送裏面所有的數據。打印數據如下：

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如下：

（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如下：

（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如下：

（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，運行報錯如下：

//事件開始大小爲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如下：

（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如下：

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

創建類型		作用	備註	使用場景
基本創建	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

請尊重原創者版權，轉載請標明出處：https://blog.csdn.net/m0_37796683/article/details/102525484 謝謝！

相關文章：

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.延遲創建

理解RecyclerView（六）—RecyclerView的滑動原理

Android動畫篇(四)—— 屬性動畫ValueAnimator的高級進階

OkHttp3源碼詳解

Android動畫篇(二)—— 代碼實現alpha、scale、translate、rotate、set及插值器動畫

Android動畫篇(七)—— 補間動畫(Tween Animation)的運行原理

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

linux以太網驅動總結