Rxjava的操作符（1）------创建操作符和变换操作符

最新推荐文章于 2023-08-25 19:51:44 发布

李瑶.

最新推荐文章于 2023-08-25 19:51:44 发布

阅读量287

点赞数

分类专栏： Android的进阶知识文章标签： java android

本文链接：https://blog.csdn.net/LY010106/article/details/116708417

版权

Android的进阶知识专栏收录该内容

12 篇文章 1 订阅

订阅专栏

Rxjava的创建操作符

1.基本创建 create（）

使用Create操作符创建一个完整的Observable，可以传递onNext，onError和onCompleted等事件。

代码示例：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onNext(3);
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "onSubscribe: ");
            }

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

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

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

2. 快速创建

（1）just（）

作用:快速创建1个被观察者对象（Observable）
发送事件的特点：直接发送传入的事件（即参数）
注意1:just最多只能发送9个参数
注意2：如果你传递null给Just，它会返回一个发射null值的Observable

代码示例：

Observable.just(1, 2, 3)
               .subscribe(new Observer<Integer>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

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

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

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

（2）fromArray（）

作用：快速创建一个被观察者对象
发送事件的特点：直接发送传入的数据数组
fromArray会将数组中的数据转换为Observable对象
应用场景:被观察者对象（Observable）发送10个以上事件（数组形式),数组遍历

代码示例：

Integer[] items = { 0, 1, 2, 3, 4 };
        Observable.fromArray(items)
               .subscribe(new Observer<Integer>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

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

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

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

（3）fromIterable（）

作用:快速创建1个被观察者对象（Observable）
发送事件的特点:直接发送传入的集合List数据
应用场景:1.快速创建被观察者对象（Observable）发送10个以上事件（集合形式）2.集合元素遍历

代码示例：

List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        Observable.fromIterable(list)
               .subscribe(new Observer<Integer>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

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

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

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

（4）其他 empty，error，never等

这几个创建常常作为测试使用

empty():仅发送Complete事件，直接通知完成
error():仅发送Error事件，直接通知异常
never():不发送任何事件

代码示例：

 Observable.empty()
               .subscribe(new Observer<Object>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

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

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

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

 Observable.error(new RuntimeException())
               .subscribe(new Observer<Object>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

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

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

                   @Override
                   public void onComplete() {
                       Log.d(TAG, "onComplete: ");
                   }
               });
Observable.never()
               .subscribe(new Observer<Object>() {
                   @Override
                   public void onSubscribe(Disposable d) {
                       Log.d(TAG, "onSubscribe: "+d);
                   }

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

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

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

3. 延迟创建

延迟创建的需求场景为：

定时操作：在经过了x秒后，需要自动执行y操作
周期性操作：每隔x秒后，需要自动执行y操作

（1）defer（）

defer（）操作符会一直等待知道有观察者订阅他，然后它使用Observable工厂方法生成一个Observable，在某些情况下，等到最后（也就是刚刚被订阅）才生成Observable可以确保里面包含的是最新的数据。

使用场景：动态创建被观察者对象（Observable）获取最新的Observable对象数据

代码实例：

 //  1. 第1次对i赋值
         i= 10;

        Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
            @Override
            public ObservableSource<? extends Integer> call() throws Exception {
                return Observable.just(i);
            }
        });

        //  1. 第1次对i赋值
        i = 15;
        observable
                .subscribe(new Observer<Object>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "onSubscribe: " + d);
                    }

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

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

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

这个示例中，最后发送的数据是15。

（2）timer（）

作用:创建一个Observable，它在一个给定的延迟后发射一个特殊的值。
应用:延迟指定事件，发送一个0，一般用于检测

        // 该例子 = 延迟2s后，发送一个long类型数值
        Observable.timer(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            }

            @Override
            public void onNext(Long value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });

（3） interval（）

作用 : 按固定的时间间隔发射一个无限递增的整数序列。
interval(long,TimeUnit,Scheduler))
参数说明：参数1 = 第1次延迟时间，参数2 = 间隔时间数字，参数3 = 时间单位；

代码示例：

    Observable.interval(3, 1, TimeUnit.SECONDS)
                // 该例子发送的事件序列特点：延迟3s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个）
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    }

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

（4）intervalRange（）

作用:发送事件的特点：每隔指定时间就发送事件，可指定发送的数据（从0开始、无限递增1的的整数）的数量
参数1 = 事件序列起始点；参数2 = 事件数量；参数3 = 第1次事件延迟发送时间；参数4 = 间隔时间数字；参数5 = 时间单位

代码示例：

Observable.intervalRange(3, 10, 2, 1, TimeUnit.SECONDS)
                // 该例子发送的事件序列特点： 
                // 1. 从3开始，一共发送10个事件； 
                // 2. 第1次延迟2s发送，之后每隔2秒产生1个数字（从0开始递增1，无限个） 
                .subscribe(new Observer<Long>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    } // 默认最先调用复写的 onSubscribe（） 

                    @Override
                    public void onNext(Long value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

（5）range（）/rangeLong（）

range（）作用：连续发送 1个事件序列，可指定范围,作用类似于intervalRange（），但区别在于：无延迟发送事件

rangeLong（）类似于range（），区别在于该方法支持数据类型 = Long

参数1 = 事件序列起始点；参数2 = 事件数量；注：若设置为负数，则会抛出异常

Rxjava的变换操作符

1. 变换操作符的作用

对事件序列中的事件/整个事件序列进行加工处理（即变换），使其转变成不同的事件/整个事件序列

2. 变换操作符的汇总介绍

1. Map（）

作用：对Observable发射的每一项数据应用一个函数，执行变换操作
应用场景：数据类型转化

代码示例（将Integer类型转换为String类型）：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }

            // 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型
        }).map(new Function<Integer,String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "使用Map操作符 将事件"+integer+"的参数从 整型"+integer + " 变换成 字符串类型" + integer ;
            }
        }).subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    } // 默认最先调用复写的 onSubscribe（）

                    @Override
                    public void onNext(String value) {
                        Log.d(TAG, "接收到了事件" + value);
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

2. flatMap（）

作用：将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable
应用场景:无序的将被观察者发送的整个事件序列进行变换

这里写图片描述

代码示例如下：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }

            // 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型
        }).flatMap(new Function<Integer,  ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                    // 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件
                    // 最终合并，再发送给被观察者
                }
                return Observable.fromIterable(list);

            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            } // 默认最先调用复写的 onSubscribe（）

            @Override
            public void onNext(String value) {
                Log.d(TAG, "接收到了事件" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });

3. ConcatMap（）

作用类似与FlatMap（）操作符
区别：拆分 & 重新合并生成的事件序列的顺序 = 被观察者旧序列生产的顺序
用于场景:有序的将被观察者发送的整个事件序列进行变换
与flatMap区别为这个是有序

代码示例如下：

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
            }

            // 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型
        }).concatMap(new Function<Integer,  ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(Integer integer) throws Exception {
                final List<String> list = new ArrayList<>();
                for (int i = 0; i < 3; i++) {
                    list.add("我是事件 " + integer + "拆分后的子事件" + i);
                    // 通过flatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件
                    // 最终合并，再发送给被观察者
                }
                return Observable.fromIterable(list);

            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "开始采用subscribe连接");
            } // 默认最先调用复写的 onSubscribe（）

            @Override
            public void onNext(String value) {
                Log.d(TAG, "接收到了事件：" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "对Error事件作出响应");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "对Complete事件作出响应");
            }
        });

4. Buffrt（）

作用：定期从被观察者（Obervable）需要发送的事件中获取一定数量的事件 & 放到缓存区中，最终发送
应用场景：缓存被观察者发送的事件
参数1：缓存区大小，每次从被观察者中获取的事件数量；参数2：步长，每次获取新事件的数量

代码示例如下：

Observable.just(1, 2, 3, 4, 5)
                .buffer(3, 1) // 设置缓存区大小 & 步长
                // 缓存区大小 = 每次从被观察者中获取的事件数量
                // 步长 = 每次获取新事件的数量
                .subscribe(new Observer<List<Integer>>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.d(TAG, "开始采用subscribe连接");
                    } // 默认最先调用复写的 onSubscribe（）

                    @Override
                    public void onNext(List<Integer> stringList) {
                        Log.d(TAG, " 缓存区里的事件数量 = " + stringList.size());
                        for (Integer value : stringList) {
                            Log.d(TAG, " 事件 = " + value);
                        }
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.d(TAG, "对Error事件作出响应");
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, "对Complete事件作出响应");
                    }
                });

在这里插入图片描述