RxJava使用全记录_implementation 'io.reactivex.observable

implementation 'io.reactivex.rxjava2:rxjava:2.1.4'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

package com.example.rxjavademo;
 
import android.app.Activity;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import android.widget.Toast;
 
import com.example.entity.Persion;
 
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
 
import io.reactivex.Notification;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.BiConsumer;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.functions.Predicate;
import io.reactivex.observables.GroupedObservable;
import io.reactivex.schedulers.Schedulers;
 
 
public class MainActivity extends Activity {
    TextView tv, tv2, tv3, tv4, tv5, tv6, tv7, tv8, tv9, tv10, tv11, tv12, tv13, tv14, tv15, tv16, tv17, tv18, tv19, tv20;
    TextView tv21, tv22, tv23, tv24, tv25, tv26, tv27, tv28, tv29, tv30, tv31, tv32, tv33, tv34, tv35, tv36, tv37, tv38, tv39, tv40;
    TextView tvTest;
 
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        tv = findViewById(R.id.tv);
        tv2 = findViewById(R.id.tv2);
        tv3 = findViewById(R.id.tv3);
        tv4 = findViewById(R.id.tv4);
        tv5 = findViewById(R.id.tv5);
        tv6 = findViewById(R.id.tv6);
        tv7 = findViewById(R.id.tv7);
        tv8 = findViewById(R.id.tv8);
        tv9 = findViewById(R.id.tv9);
        tv11 = findViewById(R.id.tv11);
        tv12 = findViewById(R.id.tv12);
        tv13 = findViewById(R.id.tv13);
        tv14 = findViewById(R.id.tv14);
        tv15 = findViewById(R.id.tv15);
        tv16 = findViewById(R.id.tv16);
        tv17 = findViewById(R.id.tv17);
        tv18 = findViewById(R.id.tv18);
        tv19 = findViewById(R.id.tv19);
        tv20 = findViewById(R.id.tv20);
 
 
        tv21 = findViewById(R.id.tv21);
        tv22 = findViewById(R.id.tv22);
        tv23 = findViewById(R.id.tv23);
        tv24 = findViewById(R.id.tv24);
        tv25 = findViewById(R.id.tv25);
        tv26 = findViewById(R.id.tv26);
        tv27 = findViewById(R.id.tv27);
        tv28 = findViewById(R.id.tv28);
        tv29 = findViewById(R.id.tv29);
        tv30 = findViewById(R.id.tv30);
        tv31 = findViewById(R.id.tv31);
        tv32 = findViewById(R.id.tv32);
        tv33 = findViewById(R.id.tv33);
        tv34 = findViewById(R.id.tv34);
        tv35 = findViewById(R.id.tv35);
        tv36 = findViewById(R.id.tv36);
        tv37 = findViewById(R.id.tv37);
        tv38 = findViewById(R.id.tv38);
        tv39 = findViewById(R.id.tv39);
        tv40 = findViewById(R.id.tv40);
 
        tvTest = findViewById(R.id.tvTest);
    }
 
    public void btn(View v) {
        switch (v.getId()) {
            case R.id.tv:
                todo1();
                break;
            case R.id.tv2:
                todo2();
                break;
            case R.id.tv3:
                todo3();
                break;
            case R.id.tv4:
                todo4();
                break;
 
            case R.id.tv5:
                todo5();
                break;
 
            case R.id.tv6:
                todo6();
                break;
 
            case R.id.tv7:
                todo7();
                break;
            case R.id.tv8:
                todo8();
                break;
            case R.id.tv9:
                todo9();
                break;
            case R.id.tv10:
                todo10();
                break;
            case R.id.tv11:
                todo11();
                break;
            case R.id.tv12:
                todo12();
                break;
            case R.id.tv13:
                todo13();
                break;
            case R.id.tv14:
                todo14();
                break;
            case R.id.tv15:
                todo15();
                break;
            case R.id.tv16:
                todo16();
                break;
            case R.id.tv17:
                todo17();
                break;
            case R.id.tv18:
                todo18();
                break;
            case R.id.tv19:
                todo19();
                break;
            case R.id.tv20:
                todo20();
                break;
 
            case R.id.tv21:
                todo21();
                break;
            case R.id.tv22:
                todo22();
                break;
            case R.id.tv23:
                todo23();
                break;
            case R.id.tv24:
                todo24();
                break;
 
            case R.id.tv25:
                todo25();
                break;
 
            case R.id.tv26:
                todo26();
                break;
 
            case R.id.tv27:
                todo27();
                break;
            case R.id.tv28:
                todo28();
                break;
            case R.id.tv29:
                todo29();
                break;
            case R.id.tv30:
                todo30();
                break;
            case R.id.tv31:
                todo31();
                break;
            case R.id.tv32:
                todo32();
                break;
            case R.id.tv33:
                todo33();
                break;
            case R.id.tv34:
                todo34();
                break;
 
            case R.id.tv35:
                todo35();
                break;
 
            case R.id.tv36:
                todo36();
                break;
 
            case R.id.tv37:
                todo37();
                break;
            case R.id.tv38:
                todo38();
                break;
            case R.id.tv39:
                todo39();
                break;
            case R.id.tv40:
                todo40();
                break;
            case R.id.tvTest:
                todo45();
                break;
 
 
        }
 
    }
 
    Observable<String> observable;
 
    /**
     * 创建被观察者
     * onNext:发送该事件时，观察者会回调 onNext() 方法
     * onError:发送该事件时，观察者会回调 onError() 方法，当发送该事件之后，其他事件将不会继续发送
     * onComplete:发送该事件时，观察者会回调 onComplete() 方法，当发送该事件之后，其他事件将不会继续发送
     */
    private void todo1() {
        observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                Log.d("aaa", Thread.currentThread().getName());
                emitter.onNext("aaa");
                emitter.onNext("bbb");
                emitter.onNext("ccc");
                emitter.onComplete();
 
 
            }
        });
 
    }
 
    /**
     * 创建观察者并订阅
     */
    private void todo2() {
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("aaa", "onSubscribe");
            }
 
            @Override
            public void onNext(String str) {
                Log.d("aaa", "onNext" + str);
            }
 
            @Override
            public void onError(Throwable e) {
                Log.d("aaa", "onError");
            }
 
            @Override
            public void onComplete() {
                Log.d("aaa", "onComplete");
            }
        };
        observable.subscribe(observer);
 
    }
 
    /**
     * 链式调用
     */
    private void todo3() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
 
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(String str) {
 
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
    /**
     * 常见操作符演示-just
     * 创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。
     */
    private void todo4() {
        Observable.just("aa", "bb", "cc", "aa", "bb", "cc", "aa", "bb", "cc", "aa").subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("aaa", "onSubscribe");
            }
 
            @Override
            public void onNext(String str) {
                Log.d("aaa", "onNext" + str);
            }
 
            @Override
            public void onError(Throwable e) {
                Log.d("aaa", "onError");
            }
 
            @Override
            public void onComplete() {
                Log.d("aaa", "onComplete");
            }
        });
    }
 
    /**
     * 常见操作符演示-fromArray
     * 这个方法和 just() 类似，只不过 fromArray 可以传入多于10个的变量，并且可以传入一个数组。
     */
    private void todo5() {
        String[] strings = new String[]{"aa", "bb", "cc"};
        Observable.fromArray(strings).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("aaa", "onSubscribe");
            }
 
            @Override
            public void onNext(String str) {
                Log.d("aaa", "onNext" + str);
            }
 
            @Override
            public void onError(Throwable e) {
                Log.d("aaa", "onError");
            }
 
            @Override
            public void onComplete() {
                Log.d("aaa", "onComplete");
            }
        });
 
    }
 
    /**
     * 常见操作符演示-fromCallable
     * 这里的 Callable 是 java.util.concurrent 中的 Callable，Callable 和 Runnable 的用法基本一致，只是它会返回一个结果值，这个结果值就是发给观察者的。
     */
    private void todo6() {
        Observable.fromCallable(new Callable<String>() {
 
            @Override
            public String call() throws Exception {
                return "aaa";
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("aaa", "onNext" + s);
            }
        });
    }
 
    /**
     * 常见操作符演示-fromFuture
     * 参数中的 Future 是 java.util.concurrent 中的 Future，Future 的作用是增加了 cancel() 等方法操作 Callable，
     * 它可以通过 get() 方法来获取 Callable 返回的值。
     * doOnSubscribe() 的作用就是只有订阅时才会发送事件，具体会在下面讲解。
     */
    private void todo7() {
 
        final FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Log.d("aaa", Thread.currentThread().getName());
                return "futureTask---call";
            }
        });
 
 
        Observable.fromFuture(futureTask).doOnSubscribe(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                futureTask.run();
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("aaa", "onNext" + s);
            }
        });
    }
 
 
    /**
     * 常见操作符演示-fromIterable
     * 直接发送一个 List 集合数据给观察者
     */
    private void todo8() {
 
        List<String> stringList = new ArrayList<String>();
        stringList.add("aaa");
        stringList.add("bbb");
        stringList.add("ccc");
 
        Observable.fromIterable(stringList).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(String s) {
 
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 常见操作符演示-defer
     * 这个方法的作用就是直到被观察者被订阅后才会创建被观察者。
     */
    String s = "aaa";
 
    private void todo9() {
        Observable<String> observable = Observable.defer(new Callable<ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> call() throws Exception {
                return Observable.just(s);
            }
        });
        s = "bbb";
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d("aaa", "onSubscribe");
            }
 
            @Override
            public void onNext(String str) {
                Log.d("aaa", "onNext" + str);
            }
 
            @Override
            public void onError(Throwable e) {
                Log.d("aaa", "onError");
            }
 
            @Override
            public void onComplete() {
                Log.d("aaa", "onComplete");
            }
        };
        observable.subscribe(observer);
        s = "ccc";
        observable.subscribe(observer);
    }
 
 
    /**
     * 常见操作符演示-timer
     * 当到指定时间后就会发送一个 0L 的值给观察者。
     */
    private void todo10() {
        Observable.timer(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(Long aLong) {
                Log.d("aaa", "onNext" + aLong);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 常见操作符演示-interval
     * 每隔一段时间就会发送一个事件，这个事件是从0开始，不断增1的数字。
     */
 
    private void todo11() {
        Observable.interval(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(Long aLong) {
                Log.d("aaa", "onNext" + aLong);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 常见操作符演示-intervalRange
     * 可以指定发送事件的开始值和数量，其他与 interval() 的功能一样。
     */
    private void todo12() {
        Observable.intervalRange(0, 5, 2, 1, TimeUnit.SECONDS).
                subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
 
                    }
 
                    @Override
                    public void onNext(Long aLong) {
                        Log.d("aaa", "onNext" + aLong);
                    }
 
                    @Override
                    public void onError(Throwable e) {
 
                    }
 
                    @Override
                    public void onComplete() {
 
                    }
                });
 
 
    }
 
    /**
     * 常见操作符演示-range
     * 同时发送一定范围的事件序列。
     * 常见操作符演示-rangeLong
     * 作用与 range() 一样，只是数据类型为 Long
     */
    private void todo13() {
        Observable.range(2, 5).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(Integer integer) {
 
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 常见操作符演示-empty() & never() & error()
     * empty() ： 直接发送 onComplete() 事件
     * never()：不发送任何事件
     * error()：发送 onError() 事件
     */
    private void todo14() {
        Observable.empty().subscribe(new Observer<Object>() {
 
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(Object o) {
 
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    //===============================================转换操作符=========================================
 
    /**
     * 常见操作符演示-map
     * map 可以将被观察者发送的数据类型转变成其他的类型
     */
    private void todo15() {
        Observable.just(1, 2, 3).map(new Function<Integer, Object>() {
            @Override
            public Object apply(Integer integer) throws Exception {
                return "aaa" + integer;
            }
        }).subscribe(new Observer<Object>() {
 
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(Object o) {
                Log.d("aaa", "onNext" + o.toString());
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 常见操作符演示-flatMap
     * 这个方法可以将事件序列中的元素进行整合加工，返回一个新的被观察者。
     * flatMap() 其实与 map() 类似，但是 flatMap() 返回的是一个 Observerable
     * <p>
     * * 常见操作符演示-concatMap
     * concatMap() 和 flatMap() 基本上是一样的，只不过 concatMap() 转发出来的事件是有序的，而 flatMap() 是无序的。
     */
 
    private void todo16() {
        List<Persion> persionList = initPersionData();
        //获取所有人的action列表
        //1、map方式
//        Observable.fromIterable(persionList).map(new Function<Persion, List<Persion.PlanListBean>>() {
//            @Override
//            public List<Persion.PlanListBean> apply(Persion persion) throws Exception {
//
//                return persion.getPlanList();
//            }
//        }).subscribe(new Observer<List<Persion.PlanListBean>>() {
//            @Override
//            public void onSubscribe(Disposable d) {
//
//            }
//
//            @Override
//            public void onNext(List<Persion.PlanListBean> planListBeans) {
//                for (Persion.PlanListBean plans : planListBeans) {
//                    List<String> actions = plans.getActionList();
//                    for (String action : actions) {
//                        Log.d("aaa", "onNext" + action);
//                    }
//                }
//
//            }
//
//            @Override
//            public void onError(Throwable e) {
//
//            }
//
//            @Override
//            public void onComplete() {
//
//            }
//        });
 
 
        //2、flatMap；方式1在观察者里面出现了多重循环，当数据复杂时不好处理
 
        Observable.fromIterable(persionList).flatMap(new Function<Persion, ObservableSource<Persion.PlanListBean>>() {
            @Override
            public ObservableSource<Persion.PlanListBean> apply(Persion persion) throws Exception {
                if (persion.getPersionName().equals("chen")) {
                    return Observable.fromIterable(persion.getPlanList()).delay(1, TimeUnit.SECONDS);
                }
                return Observable.fromIterable(persion.getPlanList());
            }
        }).flatMap(new Function<Persion.PlanListBean, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Persion.PlanListBean planListBean) throws Exception {
                return Observable.fromIterable(planListBean.getActionList());
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(String s) {
                Log.d("aaa", "onNext" + s);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
 
 
    }
 
    private List<Persion> initPersionData() {
        List<String> stringList1 = new ArrayList<String>();
        stringList1.add("t1");
        stringList1.add("t2");
 
        List<String> stringList2 = new ArrayList<String>();
        stringList1.add("t3");
        stringList1.add("t4");
 
        List<Persion> persionList = new ArrayList<Persion>();
 
 
        Persion persion1 = new Persion();
        persion1.setPersionName("chen");
 
 
        List<Persion.PlanListBean> planListBeanList1 = new ArrayList<Persion.PlanListBean>();
 
        Persion.PlanListBean planListBean1 = new Persion.PlanListBean();
        planListBean1.setPlayName("plan1");
        planListBean1.setActionList(stringList1);
        planListBeanList1.add(planListBean1);
        persion1.setPlanList(planListBeanList1);
 
 
        Persion persion2 = new Persion();
        persion2.setPersionName("lv");
 
 
        List<Persion.PlanListBean> planListBeanList2 = new ArrayList<Persion.PlanListBean>();
 
        Persion.PlanListBean planListBean2 = new Persion.PlanListBean();
        planListBean2.setPlayName("plan2");
        planListBean2.setActionList(stringList2);
        planListBeanList2.add(planListBean2);
        persion2.setPlanList(planListBeanList2);
 
 
        persionList.add(persion1);
        persionList.add(persion2);
        return persionList;
    }
 
    /**
     * 常见操作符演示-buffer
     * 从需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区当中一并发出。
     * buffer 有两个参数，一个是 count，另一个 skip。
     * count 缓冲区元素的数量，skip 就代表缓冲区满了之后，发送下一次事件序列的时候要跳过多少元素。
     */
    private void todo17() {
        Observable.just(1, 2, 3, 4, 5, 6, 7).buffer(2, 2).subscribe(new Observer<List<Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(List<Integer> integers) {
                Log.d("aaa", "onNext" + integers);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
 
    }
 
    /**
     * 常见操作符演示-groupBy
     * 将发送的数据进行分组，每个分组都会返回一个被观察者。
     */
 
    private void todo18() {
        Observable.just(3, 1, 4, 3, 7, 3, 47, 9, 3).groupBy(new Function<Integer, Object>() {
            @Override
            public Object apply(Integer integer) throws Exception {
                return integer % 3;
            }
        }).subscribe(new Observer<GroupedObservable<Object, Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(final GroupedObservable<Object, Integer> objectIntegerGroupedObservable) {
 
                Log.d("aaa", "onNext    " + objectIntegerGroupedObservable.getKey());
                objectIntegerGroupedObservable.subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
 
                    }
 
                    @Override
                    public void onNext(Integer integer) {
 
                        Log.d("aaa", "onNext    " + objectIntegerGroupedObservable.getKey() + "value" + integer);
 
 
                    }
 
                    @Override
                    public void onError(Throwable e) {
 
                    }
 
                    @Override
                    public void onComplete() {
 
                    }
                });
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 常见操作符演示-scan
     * 将数据以一定的逻辑聚合起来。
     */
    private void todo19() {
        Observable.just("aa", "bb", "cc", "dd").scan(new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s2) throws Exception {
                return s + s2;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("aaa", s);
            }
        });
    }
 
 
    /**
     * 常见操作符演示-window
     * 发送指定数量的事件时，就将这些事件分为一组。window 中的 count 的参数就是代表指定的数量，例如将 count 指定为2，
     * 那么每发2个数据就会将这2个数据分成一组。
     */
    private void todo20() {
        Observable.just(1, 2, 3, 4, 5).window(2).subscribe(new Observer<Observable<Integer>>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(Observable<Integer> integerObservable) {
                integerObservable.subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
 
                    }
 
                    @Override
                    public void onNext(Integer integer) {
 
                    }
 
                    @Override
                    public void onError(Throwable e) {
 
                    }
 
                    @Override
                    public void onComplete() {
 
                    }
                });
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
//组合操作符//
 
    /**
     * 组合操作符-concat
     * 可以将多个观察者组合在一起，然后按照之前发送顺序发送事件。需要注意的是，concat() 最多只可以发送4个事件。
     */
    private void todo21() {
        Observable.concat(Observable.just("aa", "bb"), Observable.just("cc", "dd"), Observable.just("ee", "ff")).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(String s) {
                Log.d("aaa", "onNext    " + s);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
 
 
    }
 
    /**
     * 组合操作符-concatArray
     * 与 concat() 作用一样，不过 concatArray() 可以发送多于 4 个被观察者。
     */
    private void todo22() {
        Toast.makeText(this, "与 concat() 作用一样，不过 concatArray() 可以发送多于 4 个被观察者。", Toast.LENGTH_SHORT).show();
 
    }
 
    /**
     * 组合操作符-merge
     * 这个方法月 concat() 作用基本一样，知识 concat() 是串行发送事件，而 merge() 并行发送事件。
     * mergeArray() 与 merge() 的作用是一样的，只是它可以发送4个以上的被观察者
     * <p>
     * <p>
     * 此方法如果用concat  则执行兯第二个事件。
     */
    private void todo23() {
 
        Observable.merge(Observable.interval(2, TimeUnit.SECONDS).map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Exception {
                return "A" + aLong;
            }
        }), Observable.interval(2, TimeUnit.SECONDS).map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Exception {
                return "B" + aLong;
            }
        })).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(String s) {
                Log.d("aaa", "onNext    " + s);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 组合操作符-concatArrayDelayError  mergeArrayDelayError
     * 在 concatArray() 和 mergeArray() 两个方法当中，如果其中有一个被观察者发送了一个 Error 事件，那么就会停止发送事件，
     * 如果你想 onError() 事件延迟到所有被观察者都发送完事件后再执行的话，就可以使用 concatArrayDelayError() 和 mergeArrayDelayError()
     */
    private void todo24() {
        Observable observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onError(new NumberFormatException());
 
            }
        });
        Observable observable2 = Observable.just(2, 3, 4);
        Observable.concatArrayDelayError(observable, observable2).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(Integer integer) {
 
                Log.d("aaa", integer + "");
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
 
    /**
     * 组合操作符-zip
     * 会将多个被观察者合并，根据各个被观察者发送事件的顺序一个个结合起来，最终发送的事件数量会与源 Observable 中最少事件的数量一样。
     */
    private void todo25() {
        Observable observable = Observable.intervalRange(1, 5, 1, 1, TimeUnit.SECONDS).map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Exception {
                return "A" + aLong;
            }
        });
        Observable observable1 = Observable.intervalRange(2, 6, 2, 2, TimeUnit.SECONDS).map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Exception {
                return "B" + aLong;
            }
        });
        Observable.zip(observable, observable1, new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s1) throws Exception {
                return s + s1;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(String s) {
                Log.d("aaa ", s);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
 
    }
 
    /**
     * 组合操作符-combineLatest() & combineLatestDelayError()
     * combineLatest() 的作用与 zip() 类似，但是 combineLatest() 发送事件的序列是与发送的时间线有关的，
     * 当 combineLatest() 中所有的 Observable 都发送了事件，只要其中有一个 Observable 发送事件，
     * 这个事件就会和其他 Observable 最近发送的事件结合起来发送，这样可能还是比较抽象，看看以下例子代码。
     * <p>
     * combineLatestDelayError() 就是多了延迟发送 onError() 功能
     */
    private void todo26() {
        Observable observable = Observable.intervalRange(1, 4, 1, 1, TimeUnit.SECONDS).map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Exception {
                return "A" + aLong;
            }
        });
        Observable observable1 = Observable.intervalRange(1, 6, 2, 2, TimeUnit.SECONDS).map(new Function<Long, String>() {
            @Override
            public String apply(Long aLong) throws Exception {
                return "B" + aLong;
            }
        });
        Observable.combineLatest(observable, observable1, new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s1) throws Exception {
                return s + s1;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
 
            }
 
            @Override
            public void onNext(String s) {
                Log.d("aaa ", s);
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onComplete() {
 
            }
        });
    }
 
    /**
     * 组合操作符-reduce
     * 与 scan() 操作符的作用也是将发送数据以一定逻辑聚合起来，
     * 这两个的区别在于 scan() 每处理一次数据就会将事件发送给观察者，而 reduce() 会将所有数据聚合在一起才会发送事件给观察者。
     */
    private void todo27() {
        Observable.just("aa", "bb", "cc", "dd").reduce(new BiFunction<String, String, String>() {
            @Override
            public String apply(String s, String s2) throws Exception {
                return s + s2;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.d("aaa", s);
            }
        });
    }
 
    /**
     * 组合操作符-collect
     * 将数据收集到数据结构当中。
     */
 
    private void todo28() {
        Observable.just("aa", "bb", "cc").collect(new Callable<ArrayList<String>>() {
            @Override
            public ArrayList<String> call() throws Exception {
                return new ArrayList<String>();
            }
        }, new BiConsumer<ArrayList<String>, String>() {
            @Override
            public void accept(ArrayList<String> strings, String s) throws Exception {
                strings.add(s);
            }
        }).subscribe(new Consumer<ArrayList<String>>() {
            @Override
            public void accept(ArrayList<String> strings) throws Exception {
                Log.d("aaa", strings + "");
            }
        });
 
    }
 
    /**
     * 组合操作符-startWith() & startWithArray()
     * 在发送事件之前追加事件，startWith() 追加一个事件，startWithArray() 可以追加多个事件。追加的事件会先发出。
     */
    private void todo29() {
        Observable.just(1).startWith(2).startWithArray(2, 5, 7).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d("aaa", integer + "");
            }
        });
 
    }
 
    /**
     * 组合操作符-count
     * 返回被观察者发送事件的数量
     */
    private void todo30() {
        Observable.just(1, 2).count().subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.d("aaa", aLong + "");
            }
        });
 
    }
/功能操作符/
 
    /**
     * 功能操作符-delay
     * 延迟一段事件发送事件。
     */
    private void todo31() {
        Observable.just(1, 2, 3)
                .delay(2, TimeUnit.SECONDS)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d("aaa", "=======================onSubscribe");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d("aaa", "=======================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d("aaa", "=======================onSubscribe");
                    }
                });
    }
 
    /**
     * 功能操作符-doOnEach
     * Observable 每发送一件事件(包括完成、错误)之前都会先回调这个方法。
     */
    private void todo32() {
        Observable.just(1, 2, 3).doOnEach(new Consumer<Notification<Integer>>() {
            @Override
            public void accept(Notification<Integer> integerNotification) throws Exception {
                Log.d("aaa", integerNotification.getValue() + "doOnEach");
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d("aaa", integer + "");
            }
        });
 
    }
 
    /**
     * 功能操作符-doOnNext
     * Observable 每发送 onNext() 之前都会先回调这个方法。
     */
    private void todo33() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        })
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        todoLog("==================doOnNext " + integer);
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        todoLog("==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        todoLog("onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        todoLog("onNext onError");
                    }
 
                    @Override
                    public void onComplete() {
                        todoLog("onNext onComplete");
                    }
                });
    }
 
    /**
     * 功能操作符-doAfterNext/doOnComplete/doOnError/doOnSubscribe/doOnDispose
     * Observable 每发送 onNext() 之后都会回调这个方法。
     * Observable 每发送 onComplete() 之前都会回调这个方法。
     * Observable 每发送 onError() 之前都会回调这个方法。
     * Observable 每发送 onSubscribe() 之前都会回调这个方法。
     * 当调用 Disposable 的 dispose() 之后回调该方法。
     */
 
    public static final String TAG = "aaa";
 
    private void todo34() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        })
                .doOnDispose(new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.d(TAG, "==================doOnDispose ");
                    }
                })
                .subscribe(new Observer<Integer>() {
                    private Disposable d;
 
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                        this.d = d;
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "==================onNext " + integer);
                        d.dispose();
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
    /**
     * 功能操作符-doOnTerminate() & doAfterTerminate()/doFinally
     * doOnTerminate 是在 onError 或者 onComplete 发送之前回调，而 doAfterTerminate 则是 onError 或者 onComplete 发送之后回调。
     * 在所有事件发送完毕之后回调该方法。
     * <p>
     * 这里可能你会有个问题，那就是 doFinally() 和 doAfterTerminate() 到底有什么区别？区别就是在于取消订阅，
     * 如果取消订阅之后 doAfterTerminate() 就不会被回调，而 doFinally() 无论怎么样都会被回调，且都会在事件序列的最后。
     * <p>
     * onErrorReturn
     * 当接受到一个 onError() 事件之后回调，返回的值会回调 onNext() 方法，并正常结束该事件序列。
     * onErrorResumeNext
     * 当接收到 onError() 事件时，返回一个新的 Observable，并正常结束事件序列。
     * onExceptionResumeNext
     * 与 onErrorResumeNext() 作用基本一致，但是这个方法只能捕捉 Exception。
     * retry
     * 如果出现错误事件，则会重新发送所有事件序列。times 是代表重新发的次数。
     * retryUntil
     * 出现错误事件之后，可以通过此方法判断是否继续发送事件。
     * retryWhen
     * 当被观察者接收到异常或者错误事件时会回调该方法，这个方法会返回一个新的被观察者。
     * 如果返回的被观察者发送 Error 事件则之前的被观察者不会继续发送事件，如果发送正常事件则之前的被观察者会继续不断重试发送事件
     */
    private void todo35() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("chan");
                e.onNext("ze");
                e.onNext("de");
                e.onError(new Exception("404"));
                e.onNext("haha");
            }
        })
                .retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {
                        return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                            @Override
                            public ObservableSource<?> apply(Throwable throwable) throws Exception {
                                if (!throwable.toString().equals("java.lang.Exception: 404")) {
                                    return Observable.just("可以忽略的异常");
                                } else {
                                    return Observable.error(new Throwable("终止啦"));
                                }
                            }
                        });
                    }
                })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, "==================onNext " + s);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError " + e.toString());
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
 
    /**
     * 功能操作符-repeat
     * 重复发送被观察者的事件，times 为发送次数。
     * repeatWhen
     * 这个方法可以会返回一个新的被观察者设定一定逻辑来决定是否重复发送事件。
     * subscribeOn
     * 指定被观察者的线程，要注意的时，如果多次调用此方法，只有第一次有效。
     * observeOn()
     * 指定观察者的线程，每指定一次就会生效一次。
     * <p>
     * RxJava 中的调度器：
     * Schedulers.computation( )	用于使用计算任务，如事件循环和回调处理
     * Schedulers.immediate( )	当前线程
     * Schedulers.io( )	用于 IO 密集型任务，如果异步阻塞 IO 操作。
     * Schedulers.newThread( )	创建一个新的线程
     * AndroidSchedulers.mainThread()	Android 的 UI 线程，用于操作 UI。
     */
    private void todo36() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "=========================currentThread name: " + Thread.currentThread().getName());
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
                e.onComplete();
            }
        })
                .subscribeOn(Schedulers.newThread())
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "======================onSubscribe");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "======================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "======================onError");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "======================onComplete");
                    }
                });
    }
 
///过滤操作符/
 
 
    /**
     * 过滤操作符-filter
     * 通过一定逻辑来过滤被观察者发送的事件，如果返回 true 则会发送事件，否则不会发送。
     */
    private void todo37() {
        Observable.just(1, 2, 3)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer < 2;
                    }
                })
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "==================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
    /**
     * 过滤操作符-ofType
     * 可以过滤不符合该类型事件
     */
    private void todo38() {
        Observable.just(1, 2, 3, "chan", "zhide")
                .ofType(Integer.class)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "==================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
    /**
     * 过滤操作符-skip
     * 跳过正序某些事件，count 代表跳过事件的数量
     */
    private void todo39() {
        Observable.just(1, 2, 3)
                .skip(2)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "==================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
 
    /**
     * 过滤操作符-distinct
     * 过滤事件序列中的重复事件。
     */
    private void todo40() {
        Observable.just(1, 2, 3, 3, 2, 1)
                .distinct()
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "==================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
    /**
     * 过滤操作符-distinctUntilChanged
     * 过滤掉连续重复的事件
     */
    private void todo41() {
        Observable.just(1, 2, 3, 3, 2, 1)
                .distinctUntilChanged()
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "==================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
    /**
     * 过滤操作符-take
     * 控制观察者接收的事件的数量。
     * takeLast() 的作用就是控制观察者只能接受事件序列的后面几件事情
     */
    private void todo42() {
        Observable.just(1, 2, 3, 4, 5)
                .take(3)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "==================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "==================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "==================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "==================onComplete ");
                    }
                });
    }
 
    /**
     * 过滤操作符-debounce
     * 如果两件事件发送的时间间隔小于设定的时间间隔则前一件事件就不会发送给观察者。
     * throttleWithTimeout() 与此方法的作用一样
     */
    private void todo43() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                Thread.sleep(900);
                e.onNext(2);
            }
        })
                .debounce(1, TimeUnit.SECONDS)
                .subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "===================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "===================onNext " + integer);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "===================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "===================onComplete ");
                    }
                });
    }
 
    /**
     * 过滤操作符-firstElement() && lastElement()
     * firstElement() 取事件序列的第一个元素，lastElement() 取事件序列的最后一个元素。
     */
    private void todo44() {
        Observable.just(1, 2, 3, 4)
                .firstElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "====================firstElement " + integer);
                    }
                });
        Observable.just(1, 2, 3, 4)
                .lastElement()
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "====================lastElement " + integer);
                    }
                });
    }
 
    /**
     * 过滤操作符-elementAt() & elementAtOrError()
     * elementAt() 可以指定取出事件序列中事件，但是输入的 index 超出事件序列的总数的话就不会出现任何结果。
     * 这种情况下，你想发出异常信息的话就用 elementAtOrError() 。
     */
    private void todo45() {
        Observable.just(1, 2, 3, 4)
                .elementAtOrError(5)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "====================accept " + integer);
                    }
                });
    }
/条件操作符/
 
    /**
     * 条件操作符-all
     * 判断事件序列是否全部满足某个事件，如果都满足则返回 true，反之则返回 false。
     */
    private void todo46() {
        Observable.just(1, 2, 3, 4)
                .all(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer < 5;
                    }
                })
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.d(TAG, "==================aBoolean " + aBoolean);
                    }
                });
    }
 
    /**
     * 条件操作符-takeWhile
     * 可以设置条件，当某个数据满足条件时就会发送该数据，反之则不发送。
     */
    private void todo47() {
        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.d(TAG, "========================integer " + integer);
                    }
                });
    }
 
    /**
     * 条件操作符-takeUntil
     * 可以设置条件，当事件满足此条件时，下一次的事件就不会被发送了。
     */
    private void todo48() {
        Observable.just(1, 2, 3, 4, 5, 6)
                .takeUntil(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.d(TAG, "========================integer " + integer);
                    }
                });
    }
 
    /**
     * 条件操作符-skipUntil
     * 当 skipUntil() 中的 Observable 发送事件了，原来的 Observable 才会发送事件给观察者。
     */
    private void todo49() {
        Observable.intervalRange(1, 5, 0, 1, TimeUnit.SECONDS)
                .skipUntil(Observable.intervalRange(6, 5, 3, 1, TimeUnit.SECONDS))
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "========================onSubscribe ");
                    }
 
                    @Override
                    public void onNext(Long along) {
                        Log.d(TAG, "========================onNext " + along);
                    }
 
                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "========================onError ");
                    }
 
                    @Override
                    public void onComplete() {
                        Log.d(TAG, "========================onComplete ");
                    }
                });
    }
 
    /**
     * 条件操作符-sequenceEqual
     * 判断两个 Observable 发送的事件是否相同。
     */
    private void todo50() {
        Observable.sequenceEqual(Observable.just(1, 2, 3),
                Observable.just(1, 2, 3))
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.d(TAG, "========================onNext " + aBoolean);
                    }
                });
 
    }
 
    /**
     * 条件操作符-contains
     * 判断事件序列中是否含有某个元素，如果有则返回 true，如果没有则返回 false。
     */
    private void todo51() {
        Observable.just(1, 2, 3)
                .contains(3)
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        Log.d(TAG, "========================onNext " + aBoolean);
                    }
                });
    }
 
    /**
     * 条件操作符-isEmpty
     * 判断事件序列是否为空。
     */
    private void todo52() {
        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.d(TAG, "========================onNext " + aBoolean);
                    }
                });
    }
 
    /**
     * 条件操作符-amb
     * amb() 要传入一个 Observable 集合，但是只会发送最先发送事件的 Observable 中的事件，其余 Observable 将会被丢弃。
     */
    private void todo53() {
        ArrayList<Observable<Long>> list = new ArrayList<>();
        list.add(Observable.intervalRange(1, 5, 2, 1, TimeUnit.SECONDS));
        list.add(Observable.intervalRange(6, 5, 0, 1, TimeUnit.SECONDS));
        Observable.amb(list)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.d(TAG, "========================aLong " + aLong);
                    }
                });
    }
 
    /**
     * 条件操作符-defaultIfEmpty
     * 如果观察者只发送一个 onComplete() 事件，则可以利用这个方法发送一个值。
     */
    private void todo54() {
        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(TAG, "========================onNext " + integer);
                    }
                });
    }
 
 
    private void todoLog(String s) {
        Log.d("aaa", s);
    }
}