Rxjava由於其基於事件流的鏈式呼叫、邏輯簡潔 & 使用簡單的特點，深受各大 Android開發者的歡迎。因此在學習過程中全面的瞭解了下RxJava的條件操作符

all()

方法：

public final Single<Boolean> all(Predicate<? super T> predicate)

作用：
判斷被觀察者所有事件是否滿足某個事件，如果全部滿足則返回true，都在返回false
程式碼：

        Observable.just(1,3,5).all(new Predicate<Integer>() {
            @Override
 

            public boolean test(Integer integer) throws Exception {
                return integer % 2 == 1;
            }
        }).subscribe(new Consumer<Boolean>() {// Consumer是簡易版的Observer，這裡呼叫的只接收onNext方法
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e("---"
 
,"accept:"+aBoolean);
            }
        });

列印結果：

E/---: accept:true

takeUntil()

原理圖：

方法：

public final Observable<T> takeUntil(Predicate<? super T> stopPredicate) 

作用：
當事件滿足設定的條件時，該事件的下一個事件不會被髮送了。也就是說當condition == false的時候終止，包含臨界條件的item
程式碼：

        Observable.just(1
 
,3,5).takeUntil(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer > 2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("---","accept:"+integer);
            }
        });

列印結果：

E/---: accept:1
       accept:3

skipUntil()

原理圖：

方法：

public final <U> Observable<T> skipUntil(ObservableSource<U> other)

作用：
當skipUntil裡面的引數Observable傳送事件的時候，源被觀察者才會傳送事件。
程式碼：

        Observable.intervalRange(1,10,1,1,TimeUnit.SECONDS)
                .skipUntil(Observable.intervalRange(20,3,5,1,TimeUnit.SECONDS))
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e("---","accept:"+aLong);
                    }
                });

結果列印：

06-08 14:17:43.340 26552-26577/ E/---: accept:6
06-08 14:17:44.340 26552-26577/ E/---: accept:7
06-08 14:17:45.340 26552-26577/ E/---: accept:8
06-08 14:17:46.340 26552-26577/ E/---: accept:9
06-08 14:17:47.340 26552-26577/ E/---: accept:10

從上面列印結果可以發現，觀察者接收到的資料和skipUntil的引數被觀察者傳送的資料沒有關係，仍然是源被觀察者資料。

takeWhile()

原理圖：

方法：

public final Observable<T> takeWhile(Predicate<? super T> predicate)

作用：
可以設定條件，當某個資料滿足條件時就會發送該資料，反之則不傳送。當condition == false的時候終止，不包含臨界條件的item
程式碼：

        Observable.just(1,2,3,4).takeWhile(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer < 3;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("---","accept:"+integer);
            }
        });

列印結果：

E/---: accept:1
       accept:2

skipWhile()

原理圖：

方法：

public final Observable<T> skipWhile(Predicate<? super T> predicate)

作用：
可以設定條件，當某個資料滿足條件時不傳送該資料，反之則傳送。
程式碼：

        Observable.just(1,2,3,4).skipWhile(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer < 3;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("---","accept:"+integer);
            }
        });

列印結果：

E/---: accept:3
       accept:4

sequenceEqual()

原理圖：

方法：

public static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2)

作用：
判斷兩個 Observable 傳送的事件是否相同。
程式碼：

        Observable.sequenceEqual(Observable.just(1,2),Observable.just(1,2))
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.e("---","accept:"+aBoolean);
                    }
                });

結果列印:

E/---: accept:true

contains()

原理圖：

方法：

public final Single<Boolean> contains(final Object element)

作用：
判斷髮送的事件中是否包含某個元素，有則返回true
程式碼：

        Observable.just(1,3,5).contains(3).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                Log.e("---","accept:"+aBoolean);
            }
        });

列印結果：

E/---: accept:true

isEmpty()

原理圖：

方法：

public final Single<Boolean> isEmpty()

作用：
判斷事件序列是否為空。
程式碼：

Observable.create(new ObservableOnSubscribe < Integer > () {
    @Override
    public void subscribe(ObservableEmitter < Integer > e) throws Exception {
        e.onComplete();
    }
})
.isEmpty()
.subscribe(new Consumer < Boolean > () {
    @Override
    public void accept(Boolean aBoolean) throws Exception {
       Log.e("---","accept:"+aBoolean);
    }
});

結果列印：

Log.e("---","accept:"+aBoolean);

defaultIfEmpty()

方法：

public final Observable<T> defaultIfEmpty(T defaultItem)

作用：
如果觀察者只發送一個 onComplete() 事件，則可以利用這個方法傳送一個值。
程式碼：

Observable.create(new ObservableOnSubscribe < Integer > () {
    @Override
    public void subscribe(ObservableEmitter < Integer > e) throws Exception {
        e.onComplete();
    }
})
.defaultIfEmpty(666)
.subscribe(new Consumer < Integer > () {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d( "---"，"---"+integer);
    }
});

列印結果：

E/---: ---666

amb()

原理圖：

方法：

public static <T> Observable<T> amb(Iterable<? extends ObservableSource<? extends T>> sources)

作用：
amb() 要傳入一個 Observable 集合，但是隻會發送最先發送事件的 Observable 中的事件，其餘 Observable 將會被丟棄。
程式碼：

        List<Observable<Long>> list = new ArrayList<>();
        list.add(Observable.intervalRange(5,3,5,1,TimeUnit.SECONDS));
        list.add(Observable.intervalRange(1,3,3,1,TimeUnit.SECONDS));
        Observable.amb(list).subscribe(new Consumer<Long>() {

            @Override
            public void accept(Long aLong) throws Exception {
                Log.e("---","accept:"+aLong);
            }
        });

列印結果：

06-08 16:00:17.961 10456-10481/ E/---: accept:1
06-08 16:00:18.961 10456-10481/ E/---: accept:2
06-08 16:00:19.958 10456-10481/ E/---: accept:3