RxJava 操作符

简单不一定不好

已于 2023-08-28 14:16:04 修改

阅读量534

点赞数

分类专栏： Kotlin 文章标签： rxjava android kotlin 开发语言

于 2023-08-25 19:51:44 首次发布

本文链接：https://blog.csdn.net/u010498248/article/details/132481489

版权

Kotlin 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

build.gradle

    //rxjava rxandroid
    implementation "io.reactivex.rxjava3:rxjava:3.1.3"
    implementation "io.reactivex.rxjava3:rxandroid:3.0.0"

一、概述

在 RxJava 中，一个实现了 observer 接口的对象可以订阅 observable 类的实例。订阅者对 observable 发射的任何数据或者数据序列做出响应。这种模式简化了并发操作，因为它不需要阻塞等待 observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 observable 的通知。RxJava 提供了一套异步编程的 API ，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁。

RxJava 有以下三个最基本的元素：

1、被观察者（observable）

2、观察者（observer）

3、订阅者（subscribe）

创建被观察者：

//创建被观察者
val observable: Observable<Int> = Observable.create { e ->
    println("observable")
    e.onNext(100)
}

创建被观察者：

//创建观察者
val observer: Observer<Int> = object : Observer<Int> {
    override fun onSubscribe(d: Disposable?) {
        println("onSubscribe")
    }

    override fun onNext(t: Int?) {
        println("onNext：$t")
    }

    override fun onError(e: Throwable?) {
        println("onError:$e")
    }

    override fun onComplete() {
        println("onComplete")
    }
}

完成观察者与被观察者之间的订阅关系：

fun main() {
    observable.subscribe(observer)
}

输出：

onSubscribe
observable
onNext：100

也可以直接链式调用：

fun main() {
    //observable.subscribe(observer)
    //链式调用
    Observable.create<Int>{ e ->
        println("observable")
        e.onNext(100)
    }.subscribe(object : Observer<Int>{
        override fun onSubscribe(d: Disposable?) {
            println("onSubscribe")
        }

        override fun onNext(t: Int?) {
            println("onNext：$t")
        }

        override fun onError(e: Throwable?) {
            println("onError:$e")
        }

        override fun onComplete() {
            println("onComplete")
        }
    })
}

被观察者发送的事件类型有以下几种

事件种类	作用
onNext()	发送该事件时，观察者会回调 onNext() 方法
onError()	发送该事件时，观察者会回调 onError() 方法，当发送该事件之后，其他事件将不会继续发送
onComplete()	发送该事件时，观察者会回调 onComplete() 方法，当发送该事件之后，其他事件将不会继续发送

二、创建操作符

1、create()

用于创建一个 Observable 。一个正确的 observable 必须尝试调用观察者的 onCompleted 方法或者 onError 方法有且仅有一次，而且此后不能在调用 observable 的任何其他方法。

//创建被观察者
val observable: Observable<Int> = Observable.create { e ->
    println("observable")
    println(Thread.currentThread().name)
    e.onNext(100)
    e.onComplete()
}

2、just()

创建一个 observable 并发送事件，发送的事件总数不可以超出十个

Observable.just(1, 2, 3, 4).subscribe(object : Observer<Int> {
        override fun onSubscribe(d: Disposable?) {
            println("onSubscribe")
        }

        override fun onNext(t: Int?) {
            println("onNext：$t")
        }

        override fun onError(e: Throwable?) {
            println("onError:$e")
        }

        override fun onComplete() {
            println("onComplete")
        }
    })

输出：

onSubscribe
onNext：1
onNext：2
onNext：3
onNext：4
onComplete

3、fromArray()

和 just() 类似，但 fromArray 可以传入多于十个的变量，并且可以传入一个数组。

Observable.fromArray(1,2,3,4).subscribe(observer)

输出：

onSubscribe
onNext：1
onNext：2
onNext：3
onNext：4
onComplete

4、fromCallable()

Callable 包含一个返回值，这个结果值就是发给观察者

Observable.fromCallable(object : Callable<Int> {
        override fun call(): Int {
            return 100
        }
    }).subscribe(observer)

5、fromFuture()

这里的 future 是指 java.util.concurrent 中的 Future，Future 的作用是增加了 cancel() 等方法操作 Callable ,它可以通过 get() 方法来获取 Callable 返回值

val futureTask = FutureTask<Int>(object : Callable<Int> {
        override fun call(): Int {
            return 12
        }
    })
    Observable.fromFuture(futureTask).doOnSubscribe(object : Consumer<Disposable> {
        override fun accept(t: Disposable?) {
            futureTask.run()
        }
    }).subscribe(observer)

6、fromIterable()

发送 List 集合数据给观察者

val list = arrayListOf<Int>(1, 2, 3)
Observable.fromIterable(list).subscribe(observer)

7、defer()

defer 操作符会一直等待直到有观察者订阅它，然后它使用 observable 工厂方法生成一个 observable 。它对每一个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个 observable，实际上每一个订阅者获取到的都是它们自己的单独的数据序列。在某些情况下，直到发生订阅时才生成 observable 可以确保 observable 包含最新的数据。

8、timer()

延迟指定时间后发送一个大小 0 的值给观察者

        Observable.timer(2, TimeUnit.SECONDS)
            .subscribe {
                println("value:$it")
            }

9、interval()

每隔一段时间就发送一个事件，传递的值从 0 开始不断增加 1

 Observable.interval(1, TimeUnit.SECONDS)
        .subscribe {
            println("value is: $it")
        }

10、intervalRange()

可以指定发送事件的开始值和数量，其他与 interval 的功能一样

Observable.intervalRange(2,3,4,5,TimeUnit.SECONDS)
        .subscribe(){
            println("value is :$it")
        }

起始值从 2 开始递增，事件共传递三次，第一次事件在订阅后延迟 4 秒触发，之后每次延迟 5 秒

11、range()

发送指定范围的事件序列

Observable.range(1,5)
        .subscribe(){
            println("range is : $it")
        }

12、rangeLong()

作用与 range() 一样，只是数据类型是 Long

Observable.rangeLong(1, 5)
        .subscribe() {
            println("rangeLong is: $it")
        }

13、empty() & never() & error()

Observable.empty<Int>()
        .subscribe(object : Observer<Any> {
            override fun onSubscribe(d: Disposable?) {
                println("onSubscribe")
            }

            override fun onNext(t: Any?) {
                println("onNext：$t")
            }

            override fun onError(e: Throwable?) {
                println("onError")
            }

            override fun onComplete() {
                println("onComplete")
            }

        })

换 empty() 输出：

onSubscribe
onComplete

换 never() 输出：

onSubscribe

换 error() ：

Observable.error<Throwable>(Throwable("Hello World!"))
        .subscribe(object : Observer<Any> {
            override fun onSubscribe(d: Disposable?) {
                println("onSubscribe")
            }

            override fun onNext(t: Any?) {
                println("onNext：$t")
            }

            override fun onError(e: Throwable?) {
                println("onError:${e?.message}")
            }

            override fun onComplete() {
                println("onComplete")
            }

        })

输出：

onSubscribe
onError:Hello World!

三、转换操作符

1、map()

map() 用于将被观察者发送的数据类型转变为其他的类型

    Observable.just(1, 2, 3)
        .map(object : Function<Int, String> {
            override fun apply(t: Int?): String {
                return "I'm Int:$t"
            }
        }).subscribe() {
            println("map:$it")
        }

输出：

map:I'm Int:1
map:I'm Int:2
map:I'm Int:3

2、flatMap()

用于将事件序列中的元素进行整合加工，返回一个新的被观察者

    val lists = ArrayList<String>()
    for (index in 0 until 5) {
        lists.add(index, "B_$index")
    }
    var listArray = ArrayList<ArrayList<String>>()
    listArray.add(lists)

    //for (item in lists) println("item:$item")

    Observable.fromIterable(listArray)
        .flatMap(object : Function<ArrayList<String>, ObservableSource<String>> {
            override fun apply(t: ArrayList<String>?): ObservableSource<String> {
                //返回新的被观察者
                return Observable.fromIterable(t)
            }
        }).subscribe() {
            println("flatMap is:$it")
        }

3、concatMap()

concatMap() 和 flatMap() 基本一样，只不过 concatMap() 转发出来的事件是有序的，而 flatMap 是无序的

val lists = ArrayList<String>()
    for (index in 0 until 5) {
        lists.add(index, "B_$index")
    }
    var listArray = ArrayList<ArrayList<String>>()
    listArray.add(lists)

    //for (item in lists) println("item:$item")

    Observable.fromIterable(listArray)
        .concatMap(object : Function<ArrayList<String>, ObservableSource<String>> {
            override fun apply(list: ArrayList<String>?): ObservableSource<String> {
                //返回新的被观察者
                if (list?.get(3)?.endsWith("3") == true) {
                    println("3结尾数字：${list?.get(3)}")
                    return Observable.fromIterable(list).delay(1,TimeUnit.SECONDS)
                }
                return Observable.fromIterable(list)
            }
        }).subscribe() {
            println("flatMap is:$it")
        }

4、buffer()

从需要发送的事件当中获取指定数量的事件，并将这些事件放到缓冲区当中一并发出。buffer 有两个参数，参数一 count 用于指定缓冲区大小，参数二 skip 用指定当缓冲区满了时，发送下一次事件序列的时候要跳过多少元素。

Observable.just(1, 2, 3, 4, 5,6)
        .buffer(2, 2)
        .subscribe() {
            println("buffer 缓冲区：${it.size}")
            for (item in it) println("item:$item")
        }

输出：

buffer 缓冲区：2
item:1
item:2
buffer 缓冲区：2
item:3
item:4
buffer 缓冲区：2
item:5
item:6

5、groupBy()

用于将数据进行分组，每个分组都会返回一个被观察者。groupBy 方法的返回值用于制定分组名，每返回一个新值就代表会创建一个分组。

    Observable.just(1, 2, 3)
        .groupBy(object : Function<Int, String> {
            override fun apply(t: Int?): String {
                if (t != null && t < 2) {
                    return "hello"
                }
                return "world!"
            }
        }).subscribe(object : Observer<GroupedObservable<String, Int>> {
            override fun onSubscribe(d: Disposable?) {
                println("onSubscribe")
            }

            override fun onNext(t: GroupedObservable<String, Int>?) {
                t?.subscribe() {
                    println("GroupedObservable onNext key:${t?.key}")
                    println("GroupedObservable onNext value:$it")
                }
            }

            override fun onError(e: Throwable?) {
                println("onError")
            }

            override fun onComplete() {
                println("onComplete")
            }
        })

输出：

onSubscribe
GroupedObservable onNext key:hello
GroupedObservable onNext value:1
GroupedObservable onNext key:world!
GroupedObservable onNext value:2
GroupedObservable onNext key:world!
GroupedObservable onNext value:3
onComplete

5、scan()

scan 操作符对原始 observable 发射的第一条数据应用一个函数，然后将这个函数的结果作为自己的第一项数据发射，它将函数的结果同第二项数据一起填充给这个函数来产生它自己的第二项数据，它持续进行这个过程来产生剩余的数据序列。

    Observable.just(1, 5, 3)
        .scan(object : BiFunction<Int, Int, Int> {
            override fun apply(t1: Int?, t2: Int?): Int? {
                //println("t1:$t1")
                //println("t2:$t2")
                return t1!! + t2!!
            }

        }).subscribe() {
            println("it:$it")
        }

输出：

it:1
it:6
it:9

四、组合操作符

1、concat() & concatArray()

用于将多个观察者组合一起，然后按照参数的传入顺序发送事件， concat() 最多只发送4个事件

    Observable.concat(
        Observable.just(1,2),
        Observable.just(3,4),
        Observable.just(5,6),
    ).subscribe(){
        println("concat it: $it")
    }

输出：

it: 1
it: 2
it: 3
it: 4
it: 5
it: 6

concatArray() 作用与 concat 作用一样，不过前者可以发送多于4个被观察者。

2、merge() & mergeArray()

这个方法与 concat 作用基本一样，只是 concat 是串行发送事件，而 merge() 并行发送事件

fun test19() {
    val observable1 = Observable.interval(1, TimeUnit.SECONDS).map(object : Function<Long, String> {
        override fun apply(aLong: Long?): String {
            return "Test_A_$aLong"
        }
    })
    val observable2 = Observable.interval(1, TimeUnit.SECONDS).map(object : Function<Long, String> {
        override fun apply(aLong: Long?): String {
            return "Test_B_$aLong"
        }
    })

    Observable.merge(observable1, observable2)
        .subscribe {
            println("it: $it")
        }

    Thread.sleep(3000)
}

输出：

it: Test_B_0
it: Test_A_0
it: Test_A_1
it: Test_B_1
it: Test_B_2
it: Test_A_2

3、concatArrayDelayError() & mergeArrayDelayError()

在 concatArray() 和 mergeArray() 两个方法当中，如果其中有一个被观察者发送了一个 Error 事件，那么就会停止发送事件，如果想 onError() 事件延迟到所有被观察者都发送完事件后在执行的话，可以使用 concatArrayDelayError() 和 mergeArrayDelayError() 。

首先使用 concatArray() 来验证其发送 onError() 事件是否会中断其他被观察者的发送事件

fun test20(){
    val observable1 = Observable.create<Int> {
        it.onNext(1)
        it.onNext(2)
        it.onError(Exception("Normal Exception"))
    }
    val observable2 = Observable.just(1,2,3)

    Observable.concatArray(observable1, observable2)
        .subscribe(object : Observer<Int> {
            override fun onSubscribe(d: Disposable?) {
                println("onSubscribe")
            }

            override fun onNext(t: Int?) {
                println("onNext:$t")
            }

            override fun onError(e: Throwable?) {
                println("onError：${e?.message}")
            }

            override fun onComplete() {
                println("onComplete")
            }

        })
}

输出：

onSubscribe
onNext:1
onNext:2
onError：Normal Exception

换为 concatArrayDelayError()

fun test20(){
    val observable1 = Observable.create<Int> {
        it.onNext(1)
        it.onNext(2)
        it.onError(Exception("Normal Exception"))
    }
    val observable2 = Observable.just(1,2,3)

    Observable.concatArrayDelayError(observable1, observable2)
        .subscribe(object : Observer<Int> {
            override fun onSubscribe(d: Disposable?) {
                println("onSubscribe")
            }

            override fun onNext(t: Int?) {
                println("onNext:$t")
            }

            override fun onError(e: Throwable?) {
                println("onError：${e?.message}")
            }

            override fun onComplete() {
                println("onComplete")
            }

        })
}

输出：

onSubscribe
onNext:1
onNext:2
onNext:1
onNext:2
onNext:3
onError：Normal Exception

4、zip()

zip() 操作符返回一个 observable ，它使用这个函数按顺序结合两个或者多个 observable 发射的数据项，然后它发射这个函数返回的结果，它按照严格的顺序应用这个函数，它只发射与发射数据项最少得那个 observable 一样多的数据。

fun test21() {
    Observable.zip(
        Observable.just(1, 2, 3, 4),
        Observable.just(1, 2, 3, 4,5),
        object : BiFunction<Int, Int, String> {
            override fun apply(t1: Int?, t2: Int?): String {
                return "$t1 _ $t2"
            }
        }).subscribe(){
        println("it: $it")
    }
}

输出：

it: 1 _ 1
it: 2 _ 2
it: 3 _ 3
it: 4 _ 4

5、combineLatest() & combineLatestDelayError()

combineLatest() 的作用与 zip() 类似，combineLatest() 发送事件的序号是与发送的时间线有关的，当两个 observable 中的任何一个发射了一个数据时，通过一个指定的函数组合每个 observable 发射的最新数据，然后发射这个函数的结果。

6、reduce()

与 scan 操作符的作用类似，也是将发送以一定逻辑聚合起来，区别在于 scan 每处理一次数据就会将事件发送给观察者，而 reduce 会将所有数据聚合一起才会发送事件给观察者。

fun test22() {
    Observable.just(1, 2, 3, 4).reduce(object : BiFunction<Int, Int, Int> {
        override fun apply(t1: Int?, t2: Int?): Int {
            return t1!! + t2!!
        }
    }).subscribe() {
        println("it:$it")
    }
}

输出：

it:10

7、collect()

collect 与 reduce 类似，但它的目的是手机原始 Observable 发射的所有数据到一个可变的数据结构

fun test23(){
    Observable.just(1,2,3,4)
        .collect(object : Supplier<ArrayList<Int>> {
            override fun get(): ArrayList<Int> {
                return ArrayList()
            }

        },object : BiConsumer<ArrayList<Int>, Int> {
            override fun accept(t1: ArrayList<Int>?, t2: Int?) {
                t1?.add(t2!!)
            }
        }).subscribe(object : Consumer<ArrayList<Int>> {
            override fun accept(t: ArrayList<Int>?) {
                for (i in t!!) println("i:$i")
            }

        })
}

输出：

t:[1, 2, 3, 4]

8、startWith() & startWithArray()

在发送事件之前追加事件，startWith() 追加一个事件，startWithArray 可以追加多个事件，追加的事件会先发出。

fun test24(){
    Observable.just(4,5)
        .startWithArray(2,3)
        .subscribe{
            println("it:$it")
        }
}

输出：

it:2
it:3
it:4
it:5

9、count

返回被观察者发送事件的数量

fun test25() {
    Observable.just(1, 2, 3)
        .count()
        .subscribe(object : Consumer<Long> {
            override fun accept(aLong: Long?) {
                println("it:$aLong")
            }
        })
}

输出：

it:3

五、功能操作符

1、delay()

延迟一段时间在发送事件

fun test26() {
    Observable.just(1, 2, 3)
        .delay(2, TimeUnit.SECONDS)
        .subscribe {
            println("it:$it")
        }

    Thread.sleep(7000)
}

2、doOnEach()

observable 发送一次事件之前都会回调这个方法

fun test27() {
    Observable.just(1, 2, 3)
        .doOnEach(object : Consumer<Notification<Int>> {
            override fun accept(t: Notification<Int>?) {
                println("Notification:value=${t?.value}")
            }
        }).subscribe { println("it:$it") }
}

输出：

Notification:value=1
it:1
Notification:value=2
it:2
Notification:value=3
it:3
Notification:value=null

3、 doOnNext()

observable 发送 onNext 之前都会先回调这个方法

fun test28() {
    Observable.just(1, 2, 3)
        .doOnNext(object : Consumer<Int> {
            override fun accept(t: Int?) {
                println("doOnNext:$t")
            }
        }).subscribe { println("it:$it") }
}

输出：

doOnNext:1
it:1
doOnNext:2
it:2
doOnNext:3
it:3

4、doAfterNext

observable 发送 onNext 之后都会回调这个方法

fun test29(){
    Observable.just(1,2,3)
        .doAfterNext(object : Consumer<Int> {
            override fun accept(t: Int?) {
                println("doAfterNext:$t")
            }
        }).subscribe { println("it:$it") }
}

输出：

it:1
doAfterNext:1
it:2
doAfterNext:2
it:3
doAfterNext:3

5、doOnComlete()

observable 调用 onComplete 之前都会回调这个方法

fun test30() {
    Observable.just(1, 2, 3)
        .doOnComplete(object : Action {
            override fun run() {
                println("doOnComplete: run()")
            }
        }).subscribe { println("it:$it") }
}

输出：

it:1
it:2
it:3
doOnComplete: run()

6、doOnError()

observable 发送 onError 之前都会回调这个方法

fun test31() {
    Observable.create<Int> {
        it.onNext(1)
        it.onError(Throwable("Normal Exception"))
    }.doOnError { println("doOnError:${it.message}") }
        .subscribe({ println("it:$it") }, { t -> "throwable:${t.message}" })
}

输出：

it:1
doOnError:Normal Exception

7、doOnSubscribe()

observable 发送 onSubscribe 之前都会回调这个方法

8、doOnDispose()

当调用 Disposable 的 dispose() 之后会回调该方法

9、duOnLifecycle()

fun test33(){
    Observable.create<Int> {
        it.onNext(1)
        it.onNext(2)
        it.onComplete()
    }.doOnLifecycle(object : Consumer<Disposable> {
        override fun accept(t: Disposable?) {
            println("doOnLifecycle")
        }

    }, object : Action {
        override fun run() {
            println("doOnLifecycle run")
        }

    }).subscribe(observer)
}

输出：

doOnLifecycle
onSubscribe
onNext：1
onNext：2
onComplete

10、doOnTerminate() & doAfterTerminate()

doOnTerminate 是在 onError 或者 onComplete 发送之前回调，而 doAfterTerminate 则是 onError 或者 onComplete 发送之后回调。

11、doFinally()

在所有事件发送完毕之后回调该方法。doFinally() 和 doAfterTerminate() 区别在于取消订阅时，如果取消订阅，之后 doAfterTerminate() 就不会被回调，而 doFinally() 无论怎样都会被回调，且都会在事件序列的最后。

12、onErrorReturn()

当接受到一个 onError 事件之后回调，返回的值会回调 onNext 方法，并正常结束该事件序列。

13、onErrorResumeNext()

当接收到 onError 事件时，返回一个新的 observable，并正常结束时间序列。

14、onExceptionResumeNext()

与 onErrorResumeNext 作用基本一致，但是这个方法只能捕获 Exception ，不能捕获 Error

15、retry()

如果出现错误事件，则会重新发送所有事件序列指定次数。

fun test34() {
    Observable.create<Int> {
        it.onNext(1)
        it.onNext(2)
        it.onError(Error("Normal Error"))
    }.retry(2).subscribe(observer)
}

输出：

onSubscribe
onNext：1
onNext：2
onNext：1
onNext：2
onNext：1
onNext：2
onError:java.lang.Error: Normal Error

16 、retryUntil()

出现错误事件之后，可以通过此方法判断是否继续发送事件。

var index = 1
fun test35() {
    Observable.create<Int> {
        it.onNext(1)
        it.onNext(2)
        it.onError(Error("Normal Error"))
    }.retryUntil(object : BooleanSupplier {
        override fun getAsBoolean(): Boolean {
            return index >= 7
        }
    }).subscribe(observer)
}

输出：

onSubscribe
onNext：1
onNext：2
onNext：1
onNext：2
onNext：1
onNext：2
onError:java.lang.Error: Normal Error

17、repeat()

指定次数重复发送被观察者事件。

fun test36(){
    Observable.create<Int> {
        it.onNext(1)
        it.onNext(2)
        it.onComplete()
    }.repeat(2)
        .subscribe(observer)
}

输出：

onSubscribe
onNext：1
onNext：2
onNext：1
onNext：2
onComplete

18、repeatWhe()

返回一个新的被观察者来决定是否重复发送事件，如果新的被观察者返回 onComplete 或者 onError事件，则旧的被观察者不会发送事件，如果新的被观察者返回其他事件，则旧的观察者会发送事件。

fun test37() {
    Observable.create<Int> {
        it.onNext(1)
        it.onNext(2)
        it.onComplete()
    }.repeatWhen(object : Function<Observable<Any>, ObservableSource<Any>> {
        override fun apply(t: Observable<Any>?): ObservableSource<Any> {
            //return Observable.empty() //旧的被观察者不会发送事件
            //return Observable.error(Throwable("Normal Throwable"))//不会
            return Observable.just(1)//旧：会
        }
    }).subscribe(observer)
}

19、subscribeOn() & observeOn()

subscribeOn() 用于指定被观察者的线程，要注意的是，如果多次调用此方法，只有第一次有效

observeOn 用于指定观察者的线程，没指定一次就会生效一次

调度器	作用
Schedulers.computation()	用于使用计算任务，如事件循环和回调处理
Schedulers.immediate()	当前线程
Schedulers.io()	用于 IO 密集任务，如果异步阻塞IO操作
Schedulers.newThread()	创建一个新的线程
AndroidSchedulers.mainThread()	Android 的 UI 线程，用于操作 UI

六、过滤器

1、filter()

通过一定逻辑来过滤被观察者发送的事件，如果返回 true 则发送事件，否则不会发送

fun test38() {
    Observable.just(1, 2, 3, 4)
        .filter(object : Predicate<Int> {
            override fun test(t: Int?): Boolean {
                return t!! % 2 == 0
            }
        }).subscribe { println("it:$it") }
}

输出：

it:2
it:4

2、ofType()

过滤不符合该类型的事件

3、skip()

以正序跳过指定数量的事件

fun test39() {
    Observable.just(1,2,3,4)
        .skip(2)
        .subscribe { println("it:$it") }
}

输出：

it:3
it:4

4、skipLast()

以反序跳过指定数量的事件

fun test39() {
    Observable.just(1,2,3,4)
        .skipLast(2)
        .subscribe { println("it:$it") }
}

输出：

it:1
it:2

5、distinct()

过滤事件序列中的重复事件

fun test40() {
    Observable.just(1, 2, 3, 4, 3)
        .distinct().subscribe { println("it:$it") }
}

输出：

it:1
it:2
it:3
it:4

6、distinctUntilChanged()

过滤掉连续重复事件

fun test40() {
    Observable.just(1, 2,2,2, 3, 4, 3,3)
        .distinctUntilChanged().subscribe { println("it:$it") }
}

输出：

it:1
it:2
it:3
it:4
it:3

7、take()

控制观察者接收事件的数量

fun test41(){
    Observable.just(1,2,3,4)
        .take(3)
        .subscribe { println("it:$it") }
}

输出：

it:1
it:2
it:3

8、debounce()

如果两个事件发送的时间间隔小于设定的时间间隔，则前一件事件不会发送给观察者

9、firstElement() & lastElement()

firstElement() 取事件序列的第一个元素，lastElement 取事件序列的最后一个元素。

10、elementAt() & elementAtOrError()

elementAt 可以指定取出事件序列中事件，当时输入的 index 超出事件序列的总数的话就不会触发任何调用，想触发异常信息的话就用 elementAtOrError()

七、条件操作符

1、all()

判断事件序列是否全部满足某个事件，如果都满足则返回true，反之则返回 false.

2、takeWhile()

发射原始 observable ，知道指定的某个条件不成立的那一刻，它停止发射原始 observable，并终止自己的 observable。

3、skipWhile()

订阅原始的 observable，但是忽略它的发射物，直到指定的某个条件变为 false 时才开始发射原始 observable。

fun test42() {
    Observable.just(1, 2, 3, 4, 1, 2)
        .skipWhile(object : Predicate<Int> {
            override fun test(t: Int?): Boolean {
                return t!! < 3
            }
        }).subscribe {
            println("it:$it")
        }
}

输出：

skipWhile it:3
skipWhile it:4
skipWhile it:1
skipWhile it:2

4、takeUntil()

用于设置一个条件，当事件满足此条件时，此事件会被发送，但之后的事件就不会被发送

5、skipUnit()

当 skipUnit 中的 observable 发送事件了，原始的 observable 才会发送事件给观察者

6、sequenceEqual()

判断两个 observable 发送的事件是否相同，如果两个序列是相同的（相同的数据，相同的序列，相同的终止状态），它就发射 true ，否则发射 false。

7、contains()

判断事件序列中是否含有某个元素，如果有则返回 true ，如果没有则返回 false。

8、isEmpty()

判断事件序列是否为空

9、amb()

amb 接收一个 observable 集合，但是只会发送最先发送事件的 observable 中的事件，不管发射的是一项数据还是一个 onError 或者 onCompleted 通知，其余 observable 将会被丢弃。

10、defaultIfEmpty()

如果 observable没有发射任何值，则可以利用这个方法发送一个默认值。

参考：

https://github.com/leavesCZY/AndroidGuide/blob/master/%E4%B8%80%E6%96%87%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8%20RxJava%202.md

简单不一定不好

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava 操作符

在 RxJava 中，一个实现了 observer 接口的对象可以订阅 observable 类的实例。订阅者对 observable 发射的任何数据或者数据序列做出响应。这种模式简化了并发操作，因为它不需要阻塞等待 observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 observable 的通知。RxJava 提供了一套异步编程的 API ，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁。
复制链接

扫一扫