RxJava 操作符

已于 2023-08-28 14:16:04 修改
阅读量583 收藏
点赞数
分类专栏： Kotlin 文章标签： rxjava android kotlin 开发语言
于 2023-08-25 19:51:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010498248/article/details/132481489
版权

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

简单不一定不好
关注
专栏目录
一篇博客让你了解RxJava
一个码农的博客
12-18 2万+
RxJava可以说是2016年最流行的项目之一了，最近也接触了一下RxJava，于是想写一篇博客，希望能通过这篇博客让大家能对其进行了解，本篇博客是基于RxJava2.0，跟RxJava1.0还是有很多不同的基础知识RxJava的核心就是“异步”两个字，其最关键的东西就是两个： Observable（被观察者） Observer/Subscriber（观察者） Observable可以发出一系列的
RxJava 操作符使用
03-27
RxJava 操作符、线程调度 观察者 RxJava是一种事件驱动的基于异步数据流的编程模式，整个数据流就像一条河流，它可以被观测（监听），过滤，操控或者与其他数据流合并为一条新的数据流。三要素Rxjava原理 基于 一种...
RxJava操作符大全
热门推荐
maplejaw的博客
09-01 3万+
再也不用担心记不住RxJava中的操作符了，RxJava操作符大全，需要用时Ctrl+F一下，还有使用例子哦。
Android RxJava：这是一份RxJava使用入门学习指南，2024年Android进阶者的新篇章
最新发布
2401_87361511的博客
09-23 1168
今天关于面试的分享就到这里，还是那句话，有些东西你不仅要懂，而且要能够很好地表达出来，能够让面试官认可你的理解，例如Handler机制，这个是面试必问之题。有些晦涩的点，或许它只活在面试当中，实际工作当中你压根不会用到它，但是你要知道它是什么东西。最后在这里小编分享一份自己收录整理上述技术体系图相关的几十套腾讯、头条、阿里、美团等公司2021年的面试题，把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分。还有。
RxJava操作符
川峰的博客
05-15 3408
文章目录RxJava创建型操作符create()操作符just()操作符fromArray()操作符fromIterable()操作符differ()操作符timer()操作符interval()操作符intervalRange()操作符range()操作符rangeLong()操作符其他RxJava变换操作符map()操作符flatMap()操作符concatMap()操作符buffer()操作...
Rxjava操作符
qq_30172399的博客
05-13 1727
目录一、RxJava操作符1、创建操作符 ：创建被观察者（Observable）对象&发送事件1）Create() 操作符2）Just() 操作符3）fromIterable() 操作符4）timer()操作符5）fromArray() 操作符6）interval() 定时器7）intervalRange() 操作符8）Range() 操作符2、转换操作符：变换被观察者(Observabl...
Android + Rxjava + Rxjava操作符
04-23
1：Rxjava创建操作符：（create() ， just()，fromArray()，fromIterable() ，time() , interval()） 2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , ...
RxJava 操作符 图片
03-31
**RxJava 操作符详解** RxJava 是一个用于处理异步数据流的库，它引入了反应式编程的概念，使得事件处理变得更加灵活和易于管理。在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成...
RxJavaApp：学习RxJava操作符的APP，再加上RxJava2.x介绍
01-31
学习RxJava操作符的APP 全新升级，更漂亮，更耐看，已加入RxJava2.x介绍自行编译 展示： 下载地址 自行编译 说明： 徽标徽标网络 app中用到的数据来自： : 介绍的操作符并非全部操作符，大都是我们常用的，想要看...
RXjava中的操作符
yuxuehandong的博客
02-21 664
Rxjava中的操作符创建型操作符 interval 创建一个按固定时间间隔发射整数序列的Observable，相当于定时器 上面的代码每隔3s就会调用call方法并打印Log。其中aLong为从0开始的整数每次+1 上面代码也可以合起来写，没有特别说明，本文后面介绍操作符的示例代码都是合起来写的 range 创建发射指定范围的整数序列的Observable，可以拿来替代for循环，发射一个范围内的有序整数序列。第一个参数是起始值，并且不小于0；第二个参数为终值，左闭右开。 打印日志 repeat 创建一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值