RxJava基本使用--变换型操作符

RxJava基本使用–常用的变换型操作符

map()

把上层发送的数据进行转换然后在到观察者

//上游 发送1 2 3
        Observable.just("1", "2", "3")

                //变换操作map 可以有多个map转换  return 返回null则下游不接收
                .map(object : Function<String,Int>{
                    override fun apply(t: String): Int {
                        if (t == "1") return 1
                        else
                        return 0
                    }

                })
//                .map()

                .subscribe(
                        //下游
                        object : Observer<Int> {
                            override fun onComplete() {
                            }

                            override fun onSubscribe(d: Disposable) {
                            }

                            override fun onNext(t: Int) {
                                Log.e("==>","t===$t")
                            }

                            override fun onError(e: Throwable) {
                            }

                        })

flatMap()

把上一层变换为ObservableSource(还可以再次发射多次事件) 不排序的

Observable.just("1", "2", "3")

                .flatMap(object : Function<String,ObservableSource<Int>>{
                    override fun apply(t: String): ObservableSource<Int> {
                        return Observable.create(object : ObservableOnSubscribe<Int>{
                            override fun subscribe(emitter: ObservableEmitter<Int>) {
                                emitter.onNext(t.toInt())
                            }
                        })
                    }
                })

                .subscribe(
                        //下游
                        object : Observer<Int> {
                            override fun onComplete() {
                            }

                            override fun onSubscribe(d: Disposable) {
                            }

                            override fun onNext(t: Int) {
                                Log.e("==>","t===$t")
                            }

                            override fun onError(e: Throwable) {
                            }

                        })

concatMap()

把上一层变换为ObservableSource(还可以再次发射多次事件) 排序的

Observable.just("1", "2", "3")

                .concatMap(object : Function<String,ObservableSource<Int>>{
                    override fun apply(t: String): ObservableSource<Int> {
                        return Observable.create(object : ObservableOnSubscribe<Int>{
                            override fun subscribe(emitter: ObservableEmitter<Int>) {
                                emitter.onNext(t.toInt())
                            }
                        })
                    }
                })

                .subscribe(
                        //下游
                        object : Observer<Int> {
                            override fun onComplete() {
                            }

                            override fun onSubscribe(d: Disposable) {
                            }

                            override fun onNext(t: Int) {
                                Log.e("==>","t===$t")
                            }

                            override fun onError(e: Throwable) {
                            }

                        })

groupBy()

分组模式-转换完成后，观察者GroupedObservable类型{key=分组，细节需要再使用Observable包裹实现}
代码为：

Observable.just(3000,5000,6000,7000,9000,10000,15000)
                .groupBy(object : Function<Int,String>{
                    override fun apply(t: Int): String {
                        return if (t < 8000) "中端配置电脑" else "高端配置电脑"
                    }
                })
                .subscribe(object : Consumer<GroupedObservable<String,Int>>{
                    override fun accept(observable: GroupedObservable<String, Int>?) {
                        Log.e("accept","key="+observable!!.key)

                        observable.subscribe(object : Consumer<Int>{
                            override fun accept(t: Int?) {
                                Log.e("subscribe accept","类别："+observable.key + "，数据=$t")
                            }

                        })
                    }

                })

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kMPGwFVY-1584668784352)(media/15845974540063/15846035437263.jpg)]

buffer()

100个事件 通过buffer(20) 转换后 观察者需要用List<>来接收 返回结果为分成5个数组集合
代码为：

Observable.create(object : ObservableOnSubscribe<Int>{
            override fun subscribe(emitter: ObservableEmitter<Int>) {
                for (i in 0..99) {
                    emitter.onNext(i)
                }
                emitter.onComplete()
            }

        })
                .buffer(20)
                .subscribe(object : Observer<MutableList<Int>>{
                    override fun onComplete() {
                    }

                    override fun onSubscribe(d: Disposable) {
                    }

                    override fun onNext(t: MutableList<Int>) {
                        Log.e("==>","$t")
                    }

                    override fun onError(e: Throwable) {
                    }

                })

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hzJ3Talt-1584668784353)(media/15845974540063/15846039218945.jpg)]