RxJava的一些标志符号学习(一)

最新推荐文章于 2023-07-21 14:02:20 发布

原创最新推荐文章于 2023-07-21 14:02:20 发布 · 507 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#rxjava

Android学习小结专栏收录该内容

12 篇文章

订阅专栏

本文介绍了RxJava中关键操作符的应用，包括Just、Skip、Map、Zip等，并详细解释了如何利用这些操作符实现数据处理、转换及调度。同时探讨了CompositeDisposable的作用以及Timer、Interval等功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Just ，Skip

Just将Object对象逐一输出，skip跳过，subscribeOn表示被观察者运行线程，observeOn表示观察者运行线程，Skip（1）表示跳过第一个Object，

     public void getObservable(){

    Observable.just(item,item2)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .skip(1)
            .subscribe(new Observer<String[]>() {
                @Override
                public void onSubscribe(@NonNull Disposable d) {

                    Log.i("mao","onSubscribe");
                }

                @Override
                public void onNext(@NonNull String[] s) {

                    for(int i=0;i<s.length;i++){

                        textview.append(s[i]);
                        textview.append("\n");
                    }

                    Log.i("mao","onNext");
                }

                @Override
                public void onError(@NonNull Throwable e) {

                    Log.i("mao","onError");
                }

                @Override
                public void onComplete() {

                    Log.i("mao","onComplete");
                }
            });

}

Map

通过自定义函数转化数据，使用onNext方法发送了List数据，通过Map方法将参数T转化为需要参数

   public void getObservable2(){

    Observable observabl= Observable.create(new ObservableOnSubscribe<List<AUser>>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<List<AUser>> e) throws Exception {

            e.onNext(Utils.getAUserList());
            e.onComplete();
        }
    });

    Observer<List<User>> observer=new Observer<List<User>>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {

            Log.i("mao","onSubscribe");
        }

        @Override
        public void onNext(@NonNull List<User> users) {

            Log.i("mao","onNext");

            for(User use:users){

               // textview.append(use.getId());
               // textview.append("\n");
                textview.append(use.getName());
                textview.append("\n");
               // textview.append(use.getPsd());

            }


        }

        @Override
        public void onError(@NonNull Throwable e) {

            Log.i("mao","onError");
        }

        @Override
        public void onComplete() {

            Log.i("mao","onComplete");
        }
    };

    observabl.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .map(new Function<List<AUser>,List<User>>() {

                @Override
                public List<User> apply(@NonNull List<AUser> aUsers) throws Exception {

                    return Utils.getUserList(aUsers);
                }
            }).subscribe(observer);

}

Zip

通过zip函数将多个被观察者Observable 数据进行函数处理，输出给观察者Observer

   public void getObservable3(){

    Observable observabl= Observable.create(new ObservableOnSubscribe<List<AUser>>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<List<AUser>> e) throws Exception {

            e.onNext(Utils.getAUserList());
            e.onComplete();
        }
    });

    Observable observab2= Observable.create(new ObservableOnSubscribe<List<AUser>>() {
        @Override
        public void subscribe(@NonNull ObservableEmitter<List<AUser>> e) throws Exception {

            e.onNext(Utils.getAUserList2());
            e.onComplete();
        }
    });

    Observer<List<AUser>> observer=new Observer<List<AUser>>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {

            Log.i("mao","onSubscribe");
        }

        @Override
        public void onNext(@NonNull List<AUser> aUsers) {

            for(AUser auser:aUsers){

                textview.append(auser.getName());
                textview.append("\n");
            }

            Log.i("mao","onSubscribe");
        }

        @Override
        public void onError(@NonNull Throwable e) {


            Log.i("mao","onError");
        }

        @Override
        public void onComplete() {


            Log.i("mao","onComplete");
        }
    };


    Observable.zip(observabl, observab2, new BiFunction<List<AUser>,List<AUser>,List<AUser>>() {
        @Override
        public List<AUser> apply(@NonNull List<AUser> aUsers, @NonNull List<AUser> aUsers2) throws Exception {

            return Utils.getZipAUserList(aUsers,aUsers2);
        }
    }).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(observer);
}
</php>

CompositeDisposable

Disposable处理每一次的连接，CompositeDisposable用来存储每一次的Disposable，当Activity被销毁时，可以调用CompositeDisposable的clear方法截断所有连接。

        //Disposable,take(count)只发送前几个
          public void getObservable4(){

    Observable observable=Observable.defer(new Callable<ObservableSource<?>>() {
        @Override
        public ObservableSource<?> call() throws Exception {


            return Observable.just("one","two","three","four");
        }
    });


    DisposableObserver<String> disposableObserver=new DisposableObserver<String>() {
        @Override
        public void onNext(@NonNull String s) {
            textview.append(s);
            textview.append("\n");
            Log.i("mao","onNext");
        }

        @Override
        public void onError(@NonNull Throwable e) {

            Log.i("mao","onError");
        }

        @Override
        public void onComplete() {
            textview.append("onComplete");
            textview.append("\n");
            Log.i("mao","onComplete");
        }
    };

    compositeDisposable.add((Disposable) observable.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .take(3)
            .subscribeWith(disposableObserver));
}

Timer

延迟执行任务,注意线程问题

     public void getObservable5(){

    Observable.timer(2, TimeUnit.SECONDS,AndroidSchedulers.mainThread()).map(new Function<Long, Long>() {
        @Override
        public Long apply(@NonNull Long aLong) throws Exception {
            return Long.valueOf(6);
        }
    }).subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) throws Exception {

            textview.append(aLong+"");
            textview.append("\n");
        }
    });

}

interval

interval一下方法表示首次延迟三秒从0开始发送递增数据，之后每两秒发送一次，可以用于app的启动页面
Single发送单条数据，SingleObserver有onSuccess方法代替了onNext方法，与之对用CompletableObserver存在onComplete方法，不存在onNext方法

    public void getObservable6(){
    Observable.interval(3,2,TimeUnit.SECONDS,AndroidSchedulers.mainThread())
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) throws Exception {
                    textview.append(aLong+"");
                    textview.append("\n");
                }
            });

    Single.just("DY").subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            textview.append(s);
            textview.append("\n");
        }
    });


    SingleObserver<String> observer=new SingleObserver<String>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {

        }

        @Override
        public void onSuccess(@NonNull String s) {

        }

        @Override
        public void onError(@NonNull Throwable e) {

        }
    };
}

Flowable reduce

reduce对Flowable中数据进行处理，发送一个全新的数据

  public void getObservable8(){

    Flowable<Integer> flowable=Flowable.just(5,10);

    flowable.reduce(10,new BiFunction<Integer, Integer, Integer>() {
        @Override
        public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {

            return integer*integer2;
        }
    }).subscribe(new Consumer<Integer>() {
        @Override
        public void accept(Integer integer) throws Exception {

            textview.append(integer+"");
            textview.append("\n");
        }
    });

buffer filter

buffer 不太好理解，buffer定期收集Observable的数据放入数据包中，参数分表表示数据的长度，跨度
filter表示过滤，

  public void getObservable9(){

    Observable<List<String>> observable=Observable.just("one","two","three","four")
            .buffer(3,1);

    Observer<List<String>> observer=new Observer<List<String>>() {
        @Override
        public void onSubscribe(@NonNull Disposable d) {
            Log.i("mao","onSubscribe");
        }

        @Override
        public void onNext(@NonNull List<String> strings) {
            Log.i("mao","onNext");
            textview.append("size="+strings.size());
            for(String s:strings){
                textview.append(s);
                textview.append("\n");

            }
        }

        @Override
        public void onError(@NonNull Throwable e) {
            Log.i("mao","onError");
        }

        @Override
        public void onComplete() {

            Log.i("mao","onComplete");
        }
    };

    observable.filter(new Predicate<List<String>>() {
        @Override
        public boolean test(@NonNull List<String> strings) throws Exception {
            return strings.size()%3==0;
        }
    }).subscribe(observer);

}