RxJava系列之常用创建型操作符

最新推荐文章于 2020-11-19 19:58:09 发布

csdn_Mew

最新推荐文章于 2020-11-19 19:58:09 发布

阅读量261

点赞数

文章标签： Android RxJava

本文链接：https://blog.csdn.net/CSDN_Mew/article/details/103852571

版权

android 专栏收录该内容

86 篇文章 5 订阅

订阅专栏

系列文章

什么是创建型操作符

个人理解就是创建上游或者说被观察者或者说Observable对象的方法。名字起得那么高大上。

create

create操作符是最原始的，需要开发者手动发射事件。

 /**
     * create 操作符 创建 Observable
     * @param view
     */
    public void r01(View view) {
        // 上游
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                // 上游发射的
                e.onNext("A"); // 使用者自己发射
            }
        })
        // 订阅
        .subscribe(
                // 下游
                new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, "下游接收 onNext: " + s);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        })
        ;
    }

just

just内部发射事件，不需要开发者手动发射事件。just的参数是固定个数的，但是有多个方法重载，从一个参数的，到10个参数都有。

 /**
     * just 操作符 创建 Observable
     * @param view
     */
    public void r02(View view) {
        // 上游
        Observable.just("A", "B")  // 内部会去发射 A B

        // 订阅
        .subscribe(

                // 下游
                new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, "onNext: " + s);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                }
        );
    }

fromArray

fromArray内部发射事件，不需要开发者手动发射事件。fromArray的参数是一个数组。

 /**
     * fromArray 操作符 创建 Observable
     * @param view
     */
    public void r03(View view) {
        /*String[] strings = {"1", "2", "3"}; // 内部会去发射 1 2 3
        // 上游 被观察者
        Observable.fromArray(strings)
        // 订阅
        .subscribe(
                // 下游
                new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, "onNext: " + s);
                    }

                    @Override
                    public void onError(Throwable e) {
                    }

                    @Override
                    public void onComplete() {
                    }
                }
        );*/
        String[] strings = {"张三", "李四", "王五"};
        // for
        for (String string : strings) {
            Log.d(TAG, "r03: " + string);
        }
        Log.d(TAG, "r03: ----- ");
        // RxJava
        Observable.fromArray(strings)
                .subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.d(TAG, "accept: " + s);
                    }
                });
    }

上面使用了一个简易版的下游或者说观察者或者说Observer–Consumer。只接收onNext回调方法，并且名称修改为accept了。

empty

empty内部只会发送onCompete事件，其它的事件不会发送，下游的泛型也只能是Object，因为上游没有指定泛型的具体类型。

 /**
     * 为什么只支持Object ？
     * 上游没有发射有值得事件，下游无法确定类型，默认Object，RxJava泛型 泛型默认类型==Object
     *
     * 做一个耗时操作，不需要任何数据来刷新UI， empty的使用场景之一
     *
     * @param view
     */
    public void r04(View view) {
        // 上游无法指定 事件类型
        Observable.empty() // 内部一定会只调用 发射 onComplete 完毕事件

                // 订阅
                .subscribe(

                 // 下游 观察者
                 new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(Object integer) {
                        // 没有事件可以接受
                        Log.d(TAG, "onNext: " + integer);
                    }

                    @Override
                    public void onError(Throwable e) {

                    }

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

                        // 隐藏 加载框...
                    }
                }

                        /*// 简化版 观察者
                        new Consumer<Object>() {
                            @Override
                            public void accept(Object o) throws Exception {
                                // 接受不到
                                // 没有事件可以接受
                                Log.d(TAG, "accept: " + o);
                            }
                        }*/

                );
    }

range

range内部发射事件，会从start开始，加count个数，按顺序发射出来。

 public void r05(View view){

        // 上游  range内部会去发射
        // Observable.range(1, 8) // 1 2 3 4 5 6 7 8  从1开始加 数量共8个
        Observable.range(80, 5) // 80开始  80 81 82 83 84  加    数量共5个

        // 订阅
        .subscribe(

           // 下游
           new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "accept: " + integer);
            }
        });

    }

总结

RxJava创建型操作符 – 专门创建被观察者/上游/Observable。
观察者：就是下游，负责接收事件目前接触了完整版本Observer和简化版Consumer
create：使用者自己发射事件
just 内部自己发射的，单一对象
fromArray 内部自己发射的，数集对象
empty：内部自己发射的，下游默认是Object，无法发出有值事件，只会发射 onComplete，简化版的Consumer不会收到事件。
range：内部自己发射的，start 1 累加 count 5 最后结果：1 2 3 4 5

csdn_Mew

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava系列之常用创建型操作符

什么是创建型操作符个人理解就是创建上游或者说被观察者或者说Observable对象的方法。名字起得那么高大上。createcreate操作符是最原始的，需要开发者手动发射事件。 /** * create 操作符创建 Observable * @param view */ public void r01(View view) { // ...
复制链接

扫一扫