转--创建Observable操作符

https://blog.csdn.net/u013318615/article/details/82390992

前言
既然RxJava是基于观察者模式,那么就需要我们操作观察者(Observer)和被观察者(Observable),那么怎么创建Observable便是第一步。

创建Observable操作符
just():创建一个直接发射数据的Observable
from():从一个数组或列表中转换成Observable
create():创建一个Observable
defer():当订阅者订阅时才创建Observable,为每一个订阅创建一个新的Observable
range():创建一个指定范围的序列Observable
interval():创建一个按照规定时间间隔发射数据的Observable
timer():延时发射数据的Observable
empty():直接完成的Observable
error():直接发射错误的Observable
never():不发射数据的Observable
just()
// 发射数据
Observable.just("abc")
.subscribe({
JLog.d("onNext:it")
}, {
JLog.d("onComplete")
}, {
JLog.d("onSubscribe")
})
1
2
3
4
5
6
7
8
9
10
11
打印:

onSubscribe
onNext:abc
onComplete
1
2
3
当然,你可以使用Just发射一组数据:

Observable.just("1", "2", "3", "4", "5")
.subscribe({
JLog.d("onNext:it")
}, {
JLog.d("onComplete")
}, {
JLog.d("onSubscribe")
})
1
2
3
4
5
6
7
8
9
10
打印:

onSubscribe
onNext:1
onNext:2
onNext:3
onNext:4
onNext:5
onComplete

1
2
3
4
5
6
7
From()
当你使用Just发射一组数据时,你会发现它和From很相似:

Observable.fromArray("a", "b", "c")
.subscribe({
JLog.d(it)
})
val items = arrayListOf("1", "2", "3")
Observable.fromIterable(items)
.subscribe({
JLog.d(it)
})
1
2
3
4
5
6
7
8
9
打印:

a
b
c
1
2
3

1
2
3
4
5
6
create()
Observable.create(ObservableOnSubscribe {
try
{
if (!it.isDisposed)
{
for (i in 0..5)
{
it.onNext(i)
}
it.onComplete()
}
} catch (e: Exception)
{
it.onError(e)
}
}).subscribe({
JLog.d("onNext->it")
}, {
JLog.d("onComplete")
}, {
JLog.d("onSubscribe")
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
打印:

onSubscribe
onNext->0
onNext->1
onNext->2
onNext->3
onNext->4
onNext->5
onComplete     

1
2
3
4
5
6
7
8
Defer()
defer操作符,直到有订阅者订阅它的时候,它才会创建一个Observable,以确保获取的数据是最新的

var a = 1
val defer = Observable.defer {
Observable.just(a)
}
val just = Observable.just(a)
a++
just.subscribe({ JLog.d("just:" + it.toString()) })
defer.subscribe({
JLog.d("defer:" + it.toString())
})
1
2
3
4
5
6
7
8
9
10
我在a=1的时候用defer和just分别创建了一个Observable,在a++之后才消费他们,首先看一下结果:

just:1
defer:2
1
2
可以看到,just在创建的时候发射数据已经确定,而defer在有订阅的时候才会创建Observable,保证了a是最新值

Timer()
延时操作符,默认在computation调度器上执行,会在延时一段时间后发射数据

Observable.timer(2, TimeUnit.SECONDS)
.subscribe(object : Observer
{
override fun onComplete()
{
}

          override fun onSubscribe(d: Disposable)
          {
              JLog.d("onSubscribe")
          }

          override fun onNext(t: Long)
          {
              JLog.d("onNext")
              JLog.d("onNext发射结果:$t")
          }

          override fun onError(e: Throwable)
          {
              JLog.e(e.toString())
          }
      })

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
打印结果:

10-15 17:40:22.734 19180-19180/com.jzd.jutils.app D/JLog: onSubscribe
10-15 17:40:24.735 19180-19627/com.jzd.jutils.app D/JLog: onNext
onNext发射结果:0
1
2
3
timer在延时2s后反射了一个0

Interval()
间隔操作符,默认在computation调度器上执行,会在固定时间间隔后发射数据

Observable.interval(1, TimeUnit.SECONDS)
.subscribe({ JLog.d(it.toString()) })
1
2
打印结果

10-15 17:44:15.022 21811-21902/com.jzd.jutils.app D/JLog: 0
10-15 17:44:16.021 21811-21902/com.jzd.jutils.app D/JLog: 1
10-15 17:44:17.021 21811-21902/com.jzd.jutils.app D/JLog: 2
10-15 17:44:18.021 21811-21902/com.jzd.jutils.app D/JLog: 3
10-15 17:44:19.021 21811-21902/com.jzd.jutils.app D/JLog: 4
10-15 17:44:20.021 21811-21902/com.jzd.jutils.app D/JLog: 5
1
2
3
4
5
6
interval也有3个参数的创建方法interval(long initialDelay, long period, TimeUnit unit)先指定延时时间,然后再轮询发送。。。不过,如果你第一次用interval,你会发现这样写,interval创建的发射器根本停不下来啊,有木有~坑爹啊。所以正确的操作方式应该是这样的:

Observable.intervalRange(10, 5, 1, 1, TimeUnit.SECONDS)
.subscribe({ JLog.d(it.toString()) })
1
2
对应的方法就是intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)

Repeat
Repeat操作符可以配合创建操作符使用,在创建时配置重复策略
使用repeat重复发射一组数据

Observable.just("1", "2", "3")
.repeat(2)
.subscribe({ JLog.d(it) })
1
2
3
打印

1
2
3
1
2
3

1
2
3
4
5
6
使用repeatWhen

Observable.just("1")
.repeatWhen { Observable.timer(3, TimeUnit.SECONDS) }.subscribe({ JLog.d(it) })
JLog.d("---------------------------")
1
2
3
打印

10-15 19:49:01.646 5814-5814/com.jzd.jutils.app D/JLog: 1
---------------------------
10-15 19:49:04.646 5814-6133/com.jzd.jutils.app D/JLog: 1
1
2
3
可以看到3秒后重复发送了一次数据
使用repeatUntil

var count = 0
Observable.just("测试")
.repeatUntil { count >= 5 }
.subscribe({
JLog.d("第it")
})
1
2
3
4
5
6
打印结果:

第0次:测试
第1次:测试
第2次:测试
第3次:测试
第4次:测试
1
2
3
4
5
可以看到,repeatUntil(BooleanSupplier stop)中,当getAsBoolean返回false时会重复发射数据,当返回true时,会终止发射数据。
常用的创建操作符基本介绍完了,使用这些操作符,我们就可以愉快的创建各式各样的Observable了。
————————————————
版权声明:本文为CSDN博主「Jzd_dev」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/u013318615/article/details/82390992

你可能感兴趣的:(转--创建Observable操作符)