目錄

1. Rx簡介
2. Rxjava基礎知識
3. Rxjava創建操作符
4. Rxjava的線程操作
5. Rxjava變換過濾操作符
6. Rxjava合并、鏈接操作符
7. Rxjava條件和布爾操作符

(一):前言

Rxjava有很多操作符，正是因為這些操作符的作用，才能使Rxjava更加靈活多變。Rxjava中的而操作付包含如圖。

這里寫圖片描述

(二):Rxjava創建操作符

1:onCreate():

使用一個函數從頭創建一個Observable，這個是最常用的一個，因為我們可以用這種方式，自己定義要發射什么數據。他的參數類里包含了一個發射器，我們可以利用發射器的函數onNext, onError, onComplete來發射我們想要發射的數據。

        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                //emitter 就是發射器。
                emitter.onNext("tian");
                emitter.onComplete();
            }
        });

2:just

將單個數據裝換發射，這里不用我們去構建發射步驟，直接發射just的參數。它可以接受1到10個參數，按照參數序列逐個發送。如果參數為null，他會報出null指針異常。

Observable.just("tian").subscribe(s -> System.out.println(s));
Observable.just(1,2,3,4,5,6,7).subscribe(s -> System.out.println(s));

3:from

from可以將其他種類的對象和數據類型轉換為Observable，其中包括Furure, Iterable和數組。from有與數據對應的創建操作符，formArray() fromIterable, fromFuture().

//不管是多少個參數，observable都將他們當做一個數組，一項一項發送
Observable.fromArray("hello","tian").subscribe(s -> System.out.println(s));
List<Integer> items = new ArrayList<>();
for (int i = 0; i<10; i++) items.add(i);
//這里是處理標準的數組的。
Observable.fromIterable(items).subscribe(i -> System.out.println(i));

對于fromFuture，了解多線程的都知道，Future是多線程執行的返回，利用fromFuture創建的Observable，會發射future.get()方法的返回值。

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new MyCallBack());
        //這里是使用，fromFuture還有兩個可選參數，分別是時長和時間單位，
        //就是規定的時長后future沒有返回則Observable發射錯誤通知并終止。
        Observable.fromFuture(future).subscribe(s -> System.out.println(s));
        
    }

    static class MyCallBack implements Callable<String> {
        @Override
        public String call() {
            System.out.println("模擬一些任務");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "ok";
        }
    }

4：repeat(int n) ； n:重復次數

創建一個發射特定數據重復多次的Observable，，它不是創建一個Observable，而是重復發射原始的Observable數據，

Observable.just("tian").repeat(3).subscribe(s -> System.out.println(s));

repeatWhen()

它不是緩存和重放原始的Observable,而是根據參數，有條件的重新訂閱和發射原始數據。當原始Observable有終止通知時，repeatWhen就會決定是否重新訂閱Observable，當RepeatWhen先執行完，就會等待與那時的Observable發射完成事件，在決定是否重新訂閱。

Observable.range(0,9).repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
             @Override
             public ObservableSource<?> apply(Observable<Object> objectObservable) throws Exception {
                 return Observable.timer(10, TimeUnit.SECONDS);  //這里確定了是否重新訂閱，timer后續介紹
             }
         }).subscribe(s -> System.out.println(s));

         Thread.sleep(12000);

repeatUntil()

這個是2.0版本新的操作符，表示直到達到某一條件就不在重復發射數據，類似與循環的while條件語句。接受BooleanSupplier,返回false，重復發射數據。返回true，則終止發射數據。

         long startTime = System.currentTimeMillis();
         Observable.interval(500, TimeUnit.MILLISECONDS)
                 .take(5)
                 .repeatUntil(new BooleanSupplier() {
                     @Override
                     public boolean getAsBoolean() throws Exception {
                         return System.currentTimeMillis() - startTime > 5000;
                     }
                 }).subscribe(s-> System.out.println(s));

         Thread.sleep(6000);

5：defer:知道有觀察者訂閱才創建Observable，并為每一個訂閱者創建一個全新的Observable。

6：interval：創建一個按照固定時間間隔發射整數序列的Observable，從0開始，

Observable.interval(500, TimeUnit.MILLISECONDS)   //500，時間間隔，第二個參數時間單位。
                 .subscribe(s-> System.out.println(s));  //輸出0,1,2,3,4,5......

7:timer:

創建一個Observable，在一個給定的延遲后發射一個特殊的值。返回的特殊值為0

         Observable.timer(2,TimeUnit.SECONDS)
                 .subscribe(s->System.out.println(s));

7:range(n,m)

Range操作符發射一個范圍內的有序整數序列，你可以指定范圍的起始和長度。
range函數，它接受兩個參數，一個是范圍的起始值，一個是范圍的數據的數目

rxjava有許多創建操作符，合理的利用可以使Observable更靈活，本文的創建操作符，Flowable也都可以使用。</font>