RxJava使用实例——在开发中使用rxjava

在学习rxjava的过程中，总结了在实际应用中rxjava的运用！下面会将学到的rxjava操作符用于实际运用！

（一）循环+过滤

io.reactivex.Observable.fromIterable(users)
                .filter(new Predicate<User>() {
                    @Override
                    public boolean test(User user) throws Exception {
                        return user.getUid() == 5;
                    }
                })
                .subscribe(new Consumer<User>() {
                    @Override
                    public void accept(User user) throws Exception {
                        addLog("fromIterable->" + user.getName());
                    }
                });

使用的操作符：1、fromIterable：对数组进行循环

                         2、filter：条件过滤

实现原理：使用fromIterable操作符对数组进行遍历（也可以使用from操作符遍历数组），然后进行条件筛选，筛选成功之后符合目标的数据将会继续进入subscribe

（二）替换if语句

io.reactivex.Observable.just(1)
                .filter(new Predicate<Integer>() {
                    @Override
                    public boolean test(Integer integer) throws Exception {
                        return integer > 2;
                    }
                })
                .switchIfEmpty(new ObservableSource<Integer>() {
                    @Override
                    public void subscribe(io.reactivex.Observer<? super Integer> observer) {
                        addLog("filter->" + "我被执行啦！");
                    }
                })
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        addLog("filter->" + integer);
                    }
                });

使用的操作符：1、switchIfEmpty：如果原始Observable正常终止后仍然没有发射任何数据，就使用备用的Observable

                         2、filter：条件过滤

实现原理：首先发射条件，对条件进行筛选，如果满足条件，将会进入subscribe，否则将会进入switchIfEmpty重新发射一个新的observer

（三）切换线程

Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1");
                addLog("当前执行的线程" + Thread.currentThread().getName());//RxIoScheduler-3
                subscriber.onCompleted();
            }
        })
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .flatMap(new Func1<String, Observable<String>>() {
                    @Override
                    public Observable<String> call(String s) {
                        addLog("当前执行的线程" + Thread.currentThread().getName());
                        return Observable.just("10"); //main
                    }
                })
                .observeOn(Schedulers.io())
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        addLog("当前执行的线程" + Thread.currentThread().getName()); //RxIoScheduler-2
                    }
                });

使用的操作符：1、subscribeOn：上游（create）发射的数据所在的线程

                         2、observerOn：观察者接收的线程

实现原理：subscribeOn只在最后一次指定时有效，因为发射者只会发送一次，observerOn可反复调用

（四）倒计时功能

 //起始值，发射数量，延迟执行时间，发射周期
        Flowable.intervalRange(0 , 3 , 0 , 1 , TimeUnit.SECONDS)
                .subscribeOn(io.reactivex.schedulers.Schedulers.io())
                .observeOn(io.reactivex.android.schedulers.AndroidSchedulers.mainThread())
                .doOnNext(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        //每一次执行的事件
                    }
                })
                .doOnError(new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        addLog(throwable.toString());
                    }
                })
                .doOnComplete(new Action() {
                    @Override
                    public void run() throws Exception {
                        //执行完毕的事件
                    }
                })
                .subscribe();

使用的操作符：1、intervalRange：发射一定数量的数据，每隔一段时间去执行一次，直到执行完毕

                         2、doOnNext：当onNext发生时，它被调用，不改变数据流

                         3、doOnComplete：当onComplete发生时，它被调用（事件执行完毕）

                         4、doOnError：当onError发生时，它被调用，通常用于flatMap的错误处理

实现原理：通过计时器进行定时发送，并在发送完成之后进行销毁

（五）延时功能

Observable.timer(3 , TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        
                    }
                });

使用的操作符：1、intervalRange：发射一定数量的数据，每隔一段时间去执行一次，直到执行完毕

实现原理：相当于延时操作，在下游也可使用delay（3 ， TimeUnit.SECONDS）来进行延时