androidRxJava操作符（四）

组合操作符

1 startWith

会在源Observable发射的数据前面加上一些数据

    private void startWith()
    {
        Observable.just(3,4,5)
                .startWith(1,2)//在最前面插入1 2
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "startWith" + integer);
                    }
                });
    }

2 merge

将多个Observable合并到一个Observable中进行发射，merge可能会让合并的Observable发射的数据交错

 private void merge()
    {
        Observable<Integer> observable = Observable.just(1, 2, 3).subscribeOn(Schedulers.io());
        Observable<Integer> observable1 = Observable.just(3, 4);
        Observable.merge(observable, observable1)
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "merge" + integer);
                    }
                });
    }

3 concat

将多个Observable发射的数据进行合并发射，concat严格按照顺序发射数据，前一个Observable没发射完成时不会发射后一个Observable

    private void concat(){
        Observable<Integer> observable = Observable.just(1, 2, 3).subscribeOn(Schedulers.io());
        Observable<Integer> observable1 = Observable.just(3, 4);
        Observable.concat(observable, observable1)//有序合并
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "concat" + integer);
                    }
                });
    }

4 zip

合并两个或者多个Observable发射出的数据项，跟腱炎指定的函数变换他们，并发射一个新值。

private void zipOb()
    {
        Observable<Integer> observable = Observable.just(1, 2, 3);
        Observable<String> observable1 = Observable.just("a", "b", "c");
        Observable.zip(observable, observable1, new Func2<Integer, String, String>()
        {
            @Override
            public String call(Integer integer, String s)
            {
                return integer + s;
            }
        }).subscribe(new Action1<String>()
        {
            @Override
            public void call(String s)
            {
                Log.e(TAG, "zipOb::" + s);

            }
        });

    }

5 combineLasttest

该方法将第一个Observable发射的最后一个数据与第二个Observable发射的每个数据相结合

 private void combineLastest(){
        Observable<Integer> observable=Observable.just(1,2,3,5,6,7);
        Observable<String> observable1=Observable.just("a","b","c");
        Observable.combineLatest(observable, observable1, new Func2<Integer, String, String >()
        {//该方法将第一个Ob发射的最后一个数据与第二个Ob发射的每个数据相结合
            @Override
            public String call(Integer integer, String s)
            {
                return integer+s;
            }
        }).subscribe(new Action1<String>()
        {
            @Override
            public void call(String s)
            {
                Log.e(TAG, "combineLastest:" + s);
            }
        });

    }

辅助操作符

 

1 delay

delay操作符让原始Observable在发射每项数据之前都暂停一段指定的时间段。

private void delayOb()
    {
        Observable.create(new Observable.OnSubscribe<Long>()
        {
            @Override
            public void call(Subscriber<? super Long> subscriber)
            {
                Long currentTime = System.currentTimeMillis() / 1000;
                subscriber.onNext(currentTime);
            }
        }).delay(3, TimeUnit.SECONDS)//几秒后发送
                .subscribe(new Action1<Long>()
                {
                    @Override
                    public void call(Long aLong)
                    {
                        Log.e(TAG, "delayOb:" + (System.currentTimeMillis() / 1000 - aLong));//当前时间减去发送时间
                    }
                });
    }

2 Do系列

当Observable摸个事件发生时就会调用

 /**
     * doOnEach          为Observable注册一个回调，当Observable每发射一项数据时就会调用它一次，包括onNext onError，onComplete
     * doOnNext          只有执行onNext时才被调用
     * doOnSubscriber    当观察者订阅Observable时被调用
     * doUnOnSubscriber  取消订阅Observable时会被调用，Observable通过OnError或者onCompleted结束时，会取消订阅虽有的Subscriber。
     * doOnCompleted     当Observable正常终止调用OnComplete时会调用
     * doOnError         当Observable异常终止调用onError时会被调用
     * doOnTerminate     当Observable终止 前 就会调用
     * finally           当终止 后 就会被调用
     */
    private void doOb()
    {
        Observable.just(1, 2)
                .doOnNext(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "integer:"+integer);
                    }
                }).subscribe(new Subscriber<Integer>()
        {
            @Override
            public void onCompleted()
            {
                Log.e(TAG, "onCompleted:");
            }

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

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

    }

3 subscribeOn \ observeOn

subscribeOn操作符用于指定Observable在哪个线程中工作，如果Observable需要执行耗时操作则可以新开一个线程

observerOn操作符用来指定Observer所运行的线程，也就是发射出的数据在哪个线程中使用

private void subscribeOn()
    {
        Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>()//创建一个被观察者
        {
            @Override
            public void call(Subscriber<? super Integer> subscriber)
            {
                Log.e(TAG, "Observable：" + Thread.currentThread().getName());//获取当前线程的名字
                subscriber.onNext(1);
                subscriber.onCompleted();
            }
        });
        observable.subscribeOn(Schedulers.newThread())//表示运行在新开的线程
                .observeOn(AndroidSchedulers.mainThread())//表示运行在主线程
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "Observ：" + Thread.currentThread().getName());//获取当前线程的名字
                    }
                });
    }

4 timeout

该操作符会在Observable过了指定的一段时长没有发射任何数据，timeout操作符会以一个OnError通知终止这个Observable，或者继续执行另一个Observable

 private void timeoutOb()
    {
        Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>()
        {
            @Override
            public void call(Subscriber<? super Integer> subscriber)
            {
                for (int i = 0; i < 4; i++)
                {
                    try
                    {
                        Thread.sleep(i * 100);
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                    subscriber.onNext(i);
                }
                subscriber.onCompleted();
            }
        }).timeout(200, TimeUnit.MILLISECONDS, Observable.just(10, 11));//执行新一个Observable
        observable.subscribe(new Action1<Integer>()
        {
            @Override
            public void call(Integer integer)
            {
                Log.e(TAG, "timeoutOb:" + integer);
            }
        });
    }