Rxjava2操作符的使用

之前学习了一些Rxjava2的操作符在此记录一下，以后用到了方便查询

import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.util.Log;
import android.widget.TextView;

import com.example.administrator.myapplication.R;

import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;

import java.util.List;
import java.util.concurrent.TimeUnit;

import io.reactivex.BackpressureStrategy;
import io.reactivex.Flowable;
import io.reactivex.FlowableEmitter;
import io.reactivex.FlowableOnSubscribe;
import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.Single;
import io.reactivex.SingleObserver;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Action;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.functions.Function3;
import io.reactivex.functions.Predicate;
import io.reactivex.schedulers.Schedulers;

public class RxStudyMainActivity extends AppCompatActivity {

    public static final String TAG = RxStudyMainActivity.class.getSimpleName();


    private CompositeDisposable compositeDisposable;
    private Disposable mDisposable;

    private TextView search_src_text;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_rx_study_main);
        search_src_text = findViewById(R.id.search_src_text);
        compositeDisposable = new CompositeDisposable();
        //test1();  //flatMap、map操作符  区别在于 flatMap返回的是一个 Observable对象，map则不是
        //test2();  //zip操作符
        //test3();  //create操作符
        //test4();  //interval操作符
        //test5();  //BackpressureStrategy
        //test6();  //concat操作符
        //test7();  //distinct操作符
        //test8();  //filter操作符
        //test9();  //buffer操作符
        //test10(); //interval操作符
        //test11(); //skip操作符
        //test12(); //Single操作符
        //test13(); //debounce操作符
        //test14(); //defer操作符
        //test15(); //last操作符
        //test16(); //concat、merge操作符
        //test17(); //reduce操作符
        //test18(); //scan操作符
        //test19(); //window操作符
        //test20(); //retryWhen操作符
        //test21(); //repeatWhen操作符
        //test22(); //switchMap操作符
        //test23(); //switchIfEmpty操作符
        //test24(); //combineLatest操作符
        //test25(); //takeWhile操作符
    }

    int totalCount = 5;

    private void test25() {//takeWhile  判断条件与filter操作符类似
        Observable.interval(1, 1, TimeUnit.SECONDS).takeWhile(new Predicate<Long>() {

            @Override
            public boolean test(Long aLong) throws Exception {
                return aLong <= totalCount;
            }
        }).flatMap(new Function<Long, ObservableSource<Boolean>>() {
            @Override
            public ObservableSource<Boolean> apply(Long aLong) throws Exception {
                long l = totalCount - aLong;
                if (l == 0) {
                    return Observable.just(true); //
                } else {
                    Log.e(TAG, "takeWhile  没倒完,还剩" + l + "秒");
                    return Observable.just(false);
                }
            }
        }).subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                if (aBoolean)
                    Log.e(TAG, "takeWhile 已经倒完了");
            }
        });
    }

    private void test24() {//combineLatest  合并最新的事件，（不是最后一个事件的都只会发射当前事件源中最近最新的事件,该事件会联合最后的事件源的所有事件分别进行发送）
        //与zip不同之处 :zip每个事件源都会发射所有的事件，combineLatest则不会
        //zip属于一一对应，combineLatest 属于一对多的关系
        Observable<String> observable1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("1");
                e.onNext("2");
                e.onNext("3");
            }
        });
        Observable<String> observable2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("4");
                e.onNext("5");
                e.onNext("6");
            }
        });
        Observable<String> observable3 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("7");
                e.onNext("8");
                e.onNext("9");
            }
        });
        Observable.combineLatest(observable1, observable2, observable3, new Function3<String, String, String, Integer>() {
            @Override
            public Integer apply(String s, String s2, String s3) throws Exception {
                Log.e(TAG, "apply s==" + s + ",,,, s2==" + s2 + ",,,, s3==" + s3);
                return Integer.parseInt(s) + Integer.parseInt(s2) + Integer.parseInt(s3);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "combineLatest执行了 " + integer);
            }
        });
    }

    private void test23() {//switchIfEmpty  也可以用来实现缓存策略
        //如果原来的Observable没有发射任何数据，则使用switchIfEmpty里的Observable代替原来的Observable。
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("");
                e.onComplete();
            }
        }).filter(new Predicate<String>() {
            @Override
            public boolean test(String s) throws Exception {
                return !TextUtils.isEmpty(s);
            }
        }).switchIfEmpty(new ObservableSource<String>() {
            @Override
            public void subscribe(Observer<? super String> observer) {
                Log.e(TAG, "switchIfEmpty执行了 ");
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "switchIfEmpty  s== " + s);
            }
        });
    }

    private void test22() {//switchMap 只会发射最近最新的这一次请求（可用来优化搜索功能）
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("23");
                e.onNext("24");
                e.onNext("");
                e.onNext("25");
                // e.onNext(""); //会执行，但条件不允许，会被拦截，不会发射请求
            }
        }).debounce(2, TimeUnit.MILLISECONDS)
                .filter(new Predicate<String>() { //2秒之后发射
                    @Override
                    public boolean test(String s) throws Exception {
                        return !TextUtils.isEmpty(s);//不能为空或空字符串
                    }
                }).switchMap(new Function<String, ObservableSource<String>>() {  //发射最近的这一次
            @Override
            public ObservableSource<String> apply(String s) throws Exception {
                return Observable.fromArray(s);
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "switchMap " + s);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "switchMap 异常了" + throwable.getMessage());
            }
        });
    }

    private void test21() {//repeatWhen  只会在onComplete执行之后才会触发repeatWhen
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("ss");
                e.onComplete();
            }
        }).repeatWhen(new Function<Observable<Object>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Observable<Object> objectObservable) throws Exception {
                return objectObservable.delay(3, TimeUnit.SECONDS);//定期轮询执行
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {

            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {

            }
        }, new Action() {
            int repeatCount;

            @Override
            public void run() throws Exception {
                Log.e(TAG, "repeatWhen 重试次数 repeatCount " + (++repeatCount));
            }
        });
    }

    private void test20() { //retryWhen  重新请求  有异常就会触发
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("");
            }
        }).doOnNext(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, null);
            }
        }).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {

            int retryTotalCount = 5;
            int retryCount;

            @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 (++retryCount < retryTotalCount) {
                            Log.e(TAG, "retryWhen 重试第 " + retryCount + "次");
                            return Observable.timer(3000, TimeUnit.MILLISECONDS);
                        }
                        return Observable.error(throwable);
                    }
                });
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, "retryWhen  已完成 ");
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "Throwable  异常了 ");
                    }
                });
    }

    private void test19() {
        Observable.interval(1, TimeUnit.SECONDS) // 间隔一秒发一次
                .take(15) // 最多接收15个
                .window(3, 3)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Observable<Long>>() {
                    @Override
                    public void accept(@NonNull Observable<Long> longObservable) throws Exception {
                        Log.e(TAG, "Sub Divide begin...\n");
                        longObservable.subscribeOn(Schedulers.io())
                                .observeOn(AndroidSchedulers.mainThread())
                                .subscribe(new Consumer<Long>() {
                                    @Override
                                    public void accept(@NonNull Long aLong) throws Exception {
                                        Log.e(TAG, "Next:" + aLong + "\n");
                                    }
                                });
                    }
                });
    }

    private void test18() { //scan 与reduce用法一样，区别在于scan会把每步的结果输出,reduce只是把最终结果输出
        Observable.just(1, 2, 3, 4).scan(0, new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                Log.e(TAG, "integer  ===  " + integer);
                Log.e(TAG, "integer2  ===  " + integer2);
                return integer + integer2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "scan  ===  " + integer);
            }
        });
    }

    private void test17() {//reduce 可以设置初始值，不设置默认为数据中的第一个 integer是每次操作返回的新值，integer2为数据中的值
        Observable.just(1, 2, 3, 4).reduce(0, new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(Integer integer, Integer integer2) throws Exception {
                Log.e(TAG, "integer  ===  " + integer);
                Log.e(TAG, "integer2  ===  " + integer2);
                return integer + integer2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "reduce  ===  " + integer);
            }
        });
    }

    private void test16() { //merge是无序合并(cacheObservable不执行onComplete,netObservable也会执行)
        // concat是有序合并  (cacheObservable不执行onComplete,netObservable不会执行)
        Observable<Integer> cacheObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "cacheObservable 执行了");
                e.onNext(1);
            }
        });
        Observable<Integer> netObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "netObservable 执行了");
                e.onNext(0);
            }
        });
        Observable.merge(cacheObservable, netObservable).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "concat  ===  " + integer);
            }
        });
    }

    private void test15() {
        Observable.just(1).last(10000).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "last  == " + integer);
            }
        });
    }

    int a = 10;

    private void test14() {//defer 直到有订阅，才会创建Observable ,具有延时的效果。  代码一和代码二的区别
        // 在a=10时，虽然定义了一个Observable，但是并没有创建这个示例(这是重点)，当a=12时，这时候订阅这个Observable，则开始创建，所以对象中的a为12.
        //对比代码一
        Observable<String> observable = Observable.just("just result: " + a);//订阅之前就会执行
        a = 12;
        observable.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {  //后执行
                Log.e(TAG, "just  result == " + s);
            }
        });
        //对比代码二
        /*Observable<String> o2 =
                Observable.defer(new Callable<ObservableSource<? extends String>>() { //call方法订阅之后才会执行
                    @Override
                    public ObservableSource<? extends String> call() throws Exception {
                        return Observable.just("call == " + a);
                    }
                });
        a = 12;
        o2.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "defer  result：" + s);
            }
        });*/
    }

    private void test13() {//debounce 去除少于参数时长的事件（排除）
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1); // skip
                Thread.sleep(400);
                emitter.onNext(2); // deliver
                Thread.sleep(505);
                emitter.onNext(3); // skip
                Thread.sleep(100);
                emitter.onNext(4); // deliver
                Thread.sleep(605);
                emitter.onNext(5); // deliver
                Thread.sleep(510);
                emitter.onComplete();
            }
        }).debounce(500, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "debounce  accept == " + integer);
            }
        });
    }

    private void test12() {// Single 单一执行，只允许一个参数
        Single.just(5).subscribe(new SingleObserver<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.e(TAG, "Single  onSubscribe == " + d.isDisposed());
            }

            @Override
            public void onSuccess(Integer value) {
                Log.e(TAG, "Single  onSuccess == " + value);
            }

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

    private void test11() {
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8).skip(2) //跳过几个
                .take(2)//获取几个
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "skip take == " + integer);//输出3,4
                    }
                });
    }

    private void test10() {//interval是运行在新的线程当中
        Observable.interval(0, 1, TimeUnit.SECONDS).subscribeOn(Schedulers.io()).doOnNext(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.e(TAG, "aLong== " + aLong);//aLong为累加之后的数值
                Log.e(TAG, "Thread Name == " + Thread.currentThread().getName());
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) throws Exception {
                Log.e(TAG, "Thread Name == " + Thread.currentThread().getName());
            }
        });
    }

    private void test9() { //buffer 参数意义：count从第一位取到第几位，skip 从第一位跳过多少位之后的位置开始算起
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8).buffer(6, 5).subscribe(new Consumer<List<Integer>>() {
            @Override
            public void accept(List<Integer> integers) throws Exception {
                Log.e(TAG, "buffer size : " + integers.size());
                Log.e(TAG, "buffer value : ");
                for (Integer i : integers) {
                    Log.e(TAG, "buffer == " + i);
                }
            }
        });
    }

    private void test8() {//distinct 去重  filter过滤
        Observable.just(1, 2, 3, 10, 18, 2, 3, 6, 3).distinct().filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                Log.e(TAG, "test   " + integer);
                return integer > 10;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "accept   " + integer);
            }
        });
    }

    private void test7() {
        Observable.just(1, 2, 2, 2, 2, 2, 3, 4).distinct(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                Log.e(TAG, "apply   " + integer);
                return integer + "";
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "accept   " + integer);
            }
        });
    }

    private void test6() {//concat  连接 事件是顺序的 (如果最开始的事件的onNext执行了的话，配合first操作符，可实现缓存策略)
        //concat会三个数据源都会请求的。如何使得哪层有数据就用哪层的，之后就不走后面的逻辑了。
        //可以配合first()操作符来实现这样的效果。
        Observable<Integer> cacheObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "cacheObservable 执行了");
                if (1 == 0) {
                    e.onNext(1);
                }
                e.onComplete();
            }
        });
        Observable<Integer> diskObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "netObservable 执行了");
                e.onNext(2);
                e.onComplete();
            }
        });
        Observable<Integer> netObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.d(TAG, "netObservable 执行了");
                e.onNext(3);
                e.onComplete();
            }
        });
        Observable.concat(cacheObservable, diskObservable, netObservable).first(2).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "concat  ===  " + integer);
            }
        });
    }

    private void test5() {
        Flowable
                .create(new FlowableOnSubscribe<Integer>() {
                    @Override
                    public void subscribe(final FlowableEmitter<Integer> emitter) throws Exception {
                        Log.d(TAG, "before emit, requested = " + emitter.requested());

                        Log.d(TAG, "emit 1");
                        emitter.onNext(1);
                        Log.d(TAG, "after emit 1, requested = " + emitter.requested());

                        Log.d(TAG, "emit 2");
                        emitter.onNext(2);
                        Log.d(TAG, "after emit 2, requested = " + emitter.requested());

                        Log.d(TAG, "emit 3");
                        emitter.onNext(3);
                        Log.d(TAG, "after emit 3, requested = " + emitter.requested());

                        Log.d(TAG, "emit complete");
                        emitter.onComplete();

                        Log.d(TAG, "after emit complete, requested = " + emitter.requested());
                    }
                }, BackpressureStrategy.ERROR)
                .subscribe(new Subscriber<Integer>() {

                    @Override
                    public void onSubscribe(Subscription s) {
                        Log.d(TAG, "onSubscribe");
                        s.request(2);   //request 2
                    }

                    @Override
                    public void onNext(Integer integer) {
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable t) {
                        Log.w(TAG, "onError: ", t);
                    }

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

    }

    private void test4() {
        Flowable.interval(1, TimeUnit.MICROSECONDS).onBackpressureDrop()
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Long>() {
                    @Override
                    public void onSubscribe(Subscription s) {
                        s.request(Long.MAX_VALUE);
                    }

                    @Override
                    public void onNext(Long aLong) {

                    }

                    @Override
                    public void onError(Throwable t) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }

    private void test3() {
        Flowable.create(new FlowableOnSubscribe<String>() {
            @Override
            public void subscribe(FlowableEmitter<String> e) throws Exception {
                Log.e(TAG, "上游1 -- 哈哈哈");
                e.onNext("哈哈哈");
                Log.e(TAG, "上游1 -- 嘿嘿嘿");
                e.onNext("嘿嘿嘿");
                Log.e(TAG, "上游1 -- 啦啦啦");
                e.onNext("啦啦啦");
                e.onComplete();
            }
        }, BackpressureStrategy.ERROR)/*.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())*/.subscribe(new Subscriber<String>() {
            @Override
            public void onSubscribe(Subscription s) {
                Log.e(TAG, "onSubscribe");
                s.request(3);
            }

            @Override
            public void onNext(String string) {
                Log.e(TAG, "onNext: " + string);

            }

            @Override
            public void onError(Throwable t) {
                Log.e(TAG, "onError: ", t);
            }

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

    public void test2() {//zip 可以将多个 Observable 的数据结合为一个数据源再发射出去
        // 例如一个页面多个接口时可使用zip操作符。以最少的事件数量为准，多余的将舍弃掉
        Observable<String> stringObservable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                Log.e(TAG, "上游1 -- 哈哈哈");
                e.onNext("哈哈哈");
                //e.onComplete();
            }
        }).subscribeOn(Schedulers.io());

        Observable<Boolean> booleanObservable = Observable.create(new ObservableOnSubscribe<Boolean>() {
            @Override
            public void subscribe(ObservableEmitter<Boolean> e) throws Exception {
                Log.e(TAG, "上游2 -- true");
                e.onNext(true);
                Log.e(TAG, "上游2 -- false");
                e.onNext(false);
                Log.e(TAG, "上游2 -- false");
                e.onNext(false);
                //e.onComplete();
            }
        }).subscribeOn(Schedulers.io());

        Observable.zip(stringObservable, booleanObservable, new BiFunction<String, Boolean, String>() {
            @Override
            public String apply(String s, Boolean aBoolean) throws Exception {
                Log.e(TAG, "apply   " + s + aBoolean);
                return s + aBoolean;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "下游Consumer" + s);
            }
        });
    }

    public void test1() {
        Observable<Integer> integerObservable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                Log.e(TAG, "上游  Thread Name==" + Thread.currentThread().getName());
                e.onNext(1);
            }
        });
        integerObservable
                .subscribeOn(Schedulers.io())
                .map(new Function<Integer, String>() {
                    @Override
                    public String apply(Integer integer) throws Exception {
                        return "map转换之后的数据";
                    }
                })
                .flatMap(new Function<String, ObservableSource<String>>() {
                    @Override
                    public ObservableSource<String> apply(String string) throws Exception {
                        Log.e(TAG, "flatMap   ----   " + string);
                        return Observable.fromArray("sdf").delay(10, TimeUnit.SECONDS);
                    }
                })
                .observeOn(AndroidSchedulers.mainThread())
                .doOnNext(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.e(TAG, "doOnNext   ----   " + s);
                    }
                })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        mDisposable = d;
                    }

                    @Override
                    public void onNext(String value) {
                        search_src_text.setText(value);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });
    }


    public void test() {
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Exception());
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "Consumer");
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "Throwable");
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "Action");
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(TAG, "Disposable");
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (compositeDisposable.size() <= 0 && null != mDisposable) {
            compositeDisposable.add(mDisposable);
        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (compositeDisposable.size() > 0 && !compositeDisposable.isDisposed()) {
            compositeDisposable.dispose();
            compositeDisposable.clear();
        }
    }
}