rxjava学习笔记（二）zip操作符、Flowable

zip操作符

将多个Observable发送的消息通过一个函数合并到一起后发送，需注意：
zip操作符将消息合并后将按顺序应用该函数并发送

创建一个被观察者observable1，让其运行在io线程，且没发送一次数据都让线程休眠1s

        //创建一个observable1
        Observable observable1 = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                java.lang.Thread.sleep(1000);
                Log.d("xy:: ",1+"");
                e.onNext(2);
                java.lang.Thread.sleep(1000);
                Log.d("xy:: ",2+"");
                e.onNext(3);
                java.lang.Thread.sleep(1000);
                Log.d("xy:: ",3+"");
                e.onNext(4);
//                java.lang.Thread.sleep(1000);
                Log.d("xy:: ",4+"");
                e.onComplete();
                Log.d("xy:: ","onComplete1");
            }
        }).subscribeOn(Schedulers.io());

同上，创建一个被观察者observable2

        //创建一个observable2
        Observable observable2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("A");
                java.lang.Thread.sleep(1000);
                Log.d("xy:: ","A");
                e.onNext("B");
                java.lang.Thread.sleep(1000);
                Log.d("xy:: ","B");
                e.onNext("C");
                java.lang.Thread.sleep(1000);
                Log.d("xy:: ","C");
                e.onComplete();
                Log.d("xy:: ","onComplete2");
            }
        }).subscribeOn(Schedulers.io());

把observable1和observable2应用zip操作符后，观察者接收到的数据为应用该函数后合并的数据。可应用到非单次请求即可获取全部页面数据的场景。

        //把observable1和observable2应用zip操作符
        Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
            @Override
            public String apply(Integer integer, String s) throws Exception {
                return integer + s;
            }
        }).subscribe(new Observer<String>() {
            private Disposable disposable;

            @Override
            public void onSubscribe(Disposable d) {
                disposable = d;
            }

            @Override
            public void onNext(String value) {
                Log.d("xy:: ", value );
            }

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

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

Flowable

Flowable采取响应式拉取的方式解决‘被观察者发送消息’与‘观察者接收消息’不同步问题

 使用Flowable发送数据，Subscriber接收数据，Flowable中至多可存储128条消息，Subscriber的接收方法中调用Subscription的   request方法会接收一次数据，参数为接收数量。

io.reactivex.Flowable<Integer> flowable = io.reactivex.Flowable.create(new FlowableOnSubscribe<Integer>() {
            @Override
            public void subscribe(FlowableEmitter<Integer> e) throws Exception {
                for( int i = 0;;i++ ){
                    e.onNext( new Integer(i) );
                }
            }
        }, BackpressureStrategy.ERROR).subscribe(new Subscriber<Integer>() {

            @Override
            public void onSubscribe(Subscription s) {
                s.request(Long.MAX_VALUE);
                Log.d("xy:: ", "onSubscribe");
            }

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

            }

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

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

 已然沦落为业内最低端的人还是要多学习。。