RxJava2（二）五种被观察者

五种被观察者为Observable，Flowable,Single,Completable,Maybe。
五种被观察者可通过toObservable，toFlowable,toSingle,toCompletable,toMaybe相互转换

Observable

一简介
1.Observable即被观察者，决定什么时候触发事件以及触发怎样的事件。
2.Oberver即观察者，他可以在不同的线程中执行任务，极大的简化了并发操作，因为他创建了一个处于待命状态的观察者，可以在某一时刻响应Observable的通知，而不会造成阻塞。
3.ObservableEmitter数据发射器，发射Observable的onNext，onError，onComplete，onSubscribe方法。
4.subscribe() 订阅Observable的四个方法，只有调用此方法才会开始发射数据。其有4个构造方法：

 subscribe(onNext())
 subscribe(onNext(),onError())
 subscribe(onNext(),onError(),onComplete())
 subscribe(onNext(),onError(),onComplete(),onSubscribe())

写个重载：

//创建被观察者
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) {
                //发射数据，先检查订阅者是否取消订阅
                if (!emitter.isDisposed()){
                	emitter.onNext("Hello World");
                }
                emitter.onComplete();
            }
            //订阅给观察者，接收数据
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.d(TAG, "accept: onNext = " + s);
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
            //错误
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.d(TAG, "accept: onError = " + throwable.getMessage());
            }
            //执行完成
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "run: onComplete");
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.d(TAG, "accept: onSubscribe");
            }
        });

5.若所有观察者取消订阅，则数据流停止，若重新订阅，重新开始数据流；若部分取消订阅，不会停止数据流，仍然继续发射数据，当再次订阅，不会重新开始数据流，只会收到当前发射数据。
二，HotObservable和ColdObservable
1.HotObservable：无论有无观察者订阅，事件始终会发生，与订阅者们成一对多关系，共享信息。适用于某些事件不确定何时发生和不确定发射的元素数量。
2. ColdObservable：只有订阅者订阅了，才开始发射数据。和订阅者们成一一对应关系，各自消息是重新完整发送，彼此独立互不干扰。
3. Observable的just，create，range，fromXX等操作符创建的是ColdObservable。
4. 相互转换：publish 操作符 ColdObservable====>HotObservable；
调用connect()后才真正执行转换。

//创建被观察者HotObservable
        ConnectableObservable<String> connectableObservable =
                Observable.create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter) {
                        //发射数据
                        emitter.onNext("Hello World");
                    }
                    //开启一个新线程，将ColdObservable转换为HotObservable
                }).observeOn(Schedulers.newThread()).publish();
        //执行转化
        connectableObservable.connect();
        //订阅给观察者，接收数据
        connectableObservable.subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.d(TAG, "accept: onNext = " + s);
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
        });

相互转换：refCount 操作符HotObservable====>ColdObservable

//创建被观察者HotObservable
        ConnectableObservable<String> connectableObservable =
                Observable.create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter) {
                        //发射数据
                        emitter.onNext("Hello World");
                    }
                    //开启一个新线程，将ColdObservable转换为HotObservable
                }).observeOn(Schedulers.newThread()).publish();
        //执行转化
        connectableObservable.connect();
        //再次转化为ColdObservable
        Observable observable = connectableObservable.refCount();
        //订阅给观察者，接收数据
        observable.subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                Log.d(TAG, "accept: onNext = " + s);
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
        });

Flowable

Flowable可以看成是Observable的实现，只是它支持背压，其所有操作付强制支持背压。
Observable：
·一般处理不超过1000条数据，几乎不会造成内存溢出。
·不会背压
·处理同步流
Flowable：
·处理超过10KB的数据元素
·文件读取与分析
·读取数据库
·处理网络I/O流
·创建一个响应式的非阻塞接口

Single

只有onSuccess可onError事件，只能用onSuccess发射一个数据或一个错误通知，之后再发射数据也不会做任何处理，直接忽略。

Completable

只有onComplete和onError事件，不发射数据，没有map，flatMap操作符。常常结合andThen操作符使用。
andThen：接下来执行。

Completable.create(new CompletableOnSubscribe() {
            @Override
            public void subscribe(CompletableEmitter emitter) throws Exception {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    //完成
                    emitter.onComplete();
                } catch (InterruptedException e) {
                	//错误
                    emitter.onError(e);
                }
            }
            //Completable已执行完成，接下来执行：新建Observable发射1-10这几个数据
        }).andThen(Observable.range(1, 10))
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "accept: " + integer.toString());
                    }
                });

Maybe

没有onNext方法，同样需要onSuccess发射数据，且只能发射0或1个数据，多发也不再处理。