目录
- 目录
- 创建操作
- create
- just
- empty
- never
- error
- timer
- range
- intervalRange
- interval
- defer
- from系列
- fromArray
- fromCallable
- fromIterable
- fromFuture
- 过滤操作
- elementAt
- IgnoreElements
- take系列
- take
- takeLast
- takeUntil
- takeWhile
- skip系列
- distinct
- distinctUntilChanged
- throttleWithTimeoutdebounce
- filter
- ofType
- first
- last
- samplethrottleLast
- throttleFirst
创建操作
create
创建一个具有发射能力的Observable
Observable.create(e -> {
e.onNext("Love")
e.onNext("For")
e.onNext("You!")
e.onComplete()
}).subscribe(s -> System.out.println(s))
just
只是简单的原样发射,可将数组或Iterable当做单个数据。它接受一至九个参数
Observable.just("Love", "For", "You!")
.subscribe(s -> System.out.println(s))
empty
创建一个不发射任何数据但是正常终止的Observable
Observable.empty();
never
创建一个不发射数据也不终止的Observable
Observable.never()
error
创建一个不发射数据以一个错误终止的Observable
Observable.error(new Throwable("O__O"));
timer
在延迟一段给定的时间后发射一个简单的数字0
Observable.timer(1000, TimeUnit.MILLISECONDS)
.subscribe(s -> System.out.println(s))
range
- start:起始值
- count:一个是范 围的数据的数目。0不发送 ,负数 异常
Observable.range(5, 3)
//输出 5,6,7
.subscribe(s -> System.out.println(s))
intervalRange
- start,count:同range
- initialDelay 发送第一个值的延迟时间
- period 每两个发射物的间隔时间
- unit,scheduler 额你懂的
Observable.intervalRange(5, 100, 3000, 100,
TimeUnit.MILLISECONDS, Schedulers.io())
.subscribe(s -> System.out.println(s))
interval
相当于intervalRange的start=0
period 这个值一旦设定后是不可变化的
int[] s = new int[]{0};
Observable.interval(3000, 100 + count(s), TimeUnit.MILLISECONDS, Schedulers.io())
.subscribe(s2 -> System.out.println(s2));
private int count(int[] s) {
int result = s[0] * 1000;
s[0] = s[0] + 1;
return result;
}
defer
直到有观察者订阅时才创建Observable,并且为每个观察者创建一个新的Observable
Observable.defer(() -> Observable.just("Love", "For", "You!"))
.subscribe(s -> System.out.println(s));
from系列
fromArray
Integer[] items = {0, 1, 2, 3, 4, 5}
Observable.fromArray(items).subscribe(
integer -> System.out.println(integer))
fromCallable
Observable.fromCallable(() -> Arrays.asList("hello", "gaga"))
.subscribe(strings -> System.out.println(strings))
fromIterable
Observable.fromIterable(Arrays.asList("one", "two", "three"))
.subscribe(integer -> System.out.println(integer))
fromFuture
Observable.fromFuture(Observable.just(1).toFuture())
.doOnComplete(() -> System.out.println("complete"))
.subscribe()
过滤操作
elementAt
只发射第N项数据
Observable.just(1,2)
.elementAt(0)
.subscribe(o -> System.out.print(o ));//结果:1
Observable.range(0, 10)
// 如果索引值大于数据 项数,它会发射一个默认值(通过额外的参数指定),而不是抛出异常。
// 但是如果你传递一 个负数索引值,它仍然会抛出一个 IndexOutOfBoundsException 异常。
.elementAt(100, -100)
.subscribe(o -> System.out.print(o + "\t"));
IgnoreElements
如果你不关心一个Observable发射的数据,但是希望在它完成时或遇到错误终止时收到通知
Observable.range(0, 10)
.ignoreElements()
.subscribe(() -> System.out.println("complete")
, throwable -> System.out.println("throwable"))
take系列
take
Observable.range(0,10)
.take(3)
.subscribe(o -> System.out.print(o + "\t"))
- 变体 time系列: 发射Observable开始的那段时间发射 的数据
Observable.range(0,10)
.take(100, TimeUnit.MILLISECONDS)
.subscribe(o -> System.out.print(o + "\t"))
takeLast
Observable.range(0,10)
.takeLast(3)
.subscribe(o -> System.out.print(o + "\t"))
- 变体 time系列: 发射在原始Observable的生命周 期内最后一段时间内发射的数据
Observable.range(0,10)
.takeLast(100, TimeUnit.MILLISECONDS)
.subscribe(o -> System.out.print(o + "\t"))
takeUntil
发送complete的结束条件 当然发送结束之前也会包括这个值
Observable.just(2,3,4,5)
.takeUntil(integer -> integer>3)
.subscribe(o -> System.out.print(o + "\t"));
takeWhile
当不满足这个条件 会发送结束 不会包括这个值
Observable.just(2,3,4,5)
.takeWhile(integer ->integer<=4 )
.subscribe(o -> System.out.print(o + "\t"));
skip系列
skip
- 变体 count系列:丢弃Observable发射的前N项数据
Observable.range(0,5)
.skip(3)
.subscribe(o -> System.out.print(o + "\t"))
- 变体 time系列:丢弃原始Observable开始的那段时间发 射的数据
Observable.range(0,5)
.skip(3)
.subscribe(o -> System.out.print(o + "\t"))
skipLast
- 变体 count系列:丢弃Observable发射的前N项数据
Observable.range(0,5)
.skipLast(3)
.subscribe(o -> System.out.print(o + "\t"))
- 变体 time系列:丢弃在原始Observable的生命周 期内最后一段时间内发射的数据
Observable.range(0,10)
.skipLast(100, TimeUnit.MILLISECONDS)
.subscribe(o -> System.out.print(o + "\t"))
distinct
去重
- keySelector:这个函数根据原始Observable发射的数据项产生一个 Key,然后,比较这些Key而不是数据本身,来判定两个数据是否是不同的
Observable.just(1, 2, 1, 2, 3)
//这个函数根据原始Observable发射的数据项产生一个 Key,
// 然后,比较这些Key而不是数据本身,来判定两个数据是否是不同的
.distinct(integer -> Math.random())
.subscribe(o -> System.out.print(o + "\t"))
日志:
原因 key不同 所以当做数据不同处理
1 2 1 2 3
- 无参版本 就是内部实现了的keySelector通过生成的key就是value本身
Observable.just(1, 2, 1, 2, 3)
.distinct()
.subscribe(o -> System.out.print(o + "\t"))
日志:
1 2 3
distinctUntilChanged
(相邻去重):它只判定一个数据和它的直接前驱是 否是不同的
其他概念与distinct一样
throttleWithTimeout/debounce
操作符会过滤掉发射速率过快的数据项
throttleWithTimeout/debounce: 含义相同
如果发送数据后 指定时间段内没有新数据的话 。则发送这条
如果有新数据 则以这个新数据作为将要发送的数据项,并且重置这个时间段,重新计时。
Observable.create(e -> {
e.onNext("onNext 0")
Thread.sleep(100)
e.onNext("onNext 1")
Thread.sleep(230)
e.onNext("onNext 2")
Thread.sleep(300)
e.onNext("onNext 3")
Thread.sleep(400)
e.onNext("onNext 4")
Thread.sleep(500)
e.onNext("onNext 5")
e.onNext("onNext 6")
})
.debounce(330, TimeUnit.MILLISECONDS)
// .throttleWithTimeout(330, TimeUnit.MILLISECONDS)
.subscribeOn(Schedulers.newThread())
.observeOn(Schedulers.newThread())
.subscribe(o -> System.out.println(o))
filter
只发射通过了谓词测试的数据项
Observable.range(0, 10)
//过滤掉false的元素
.filter(integer -> integer % 2 == 0)
.subscribe(o -> System.out.print(o + "\t"))
ofType
ofType 是 filter 操作符的一个特殊形式。它过滤一个Observable只返回指定类型的数据
Observable.just(0, "what?", 1, "String", 3)
//ofType 是 filter 操作符的一个特殊形式。它过滤一个Observable只返回指定类型的数据。
.ofType(String.class)
.subscribe(o -> System.out.print(o + "\t"))
first
只发射第一项(或者满足某个条件的第一项)数 感觉和take(1) elementAt(0)差不多
Observable.range(0, 10)
//如果元数据没有发送 则有发送默认值
.first(-1)
.subscribe(o -> System.out.print(o + "\t"))
last
只发射最后一项(或者满足某个条件的最后一项)数据 感觉和takeLast(1)差不多
Observable.empty()
//如果元数据没有发送 则有发送默认值
.last(-1)
.subscribe(o -> System.out.print(o + "\t"))
sample/throttleLast
周期采样后 发送最后的数据
throttleFirst
周期采样 的第一条数据 发送
注意: 如果是已经被发送过的 则不会继续发送
Observable.create(e -> {
e.onNext("onNext 0")
Thread.sleep(100)
e.onNext("onNext 1")
Thread.sleep(50)
e.onNext("onNext 2")
Thread.sleep(70)
e.onNext("onNext 3")
Thread.sleep(200)
e.onNext("onNext 4")
e.onNext("onNext 5")
})
.subscribeOn(Schedulers.newThread())
.observeOn(Schedulers.newThread())
.sample(200, TimeUnit.MILLISECONDS,Schedulers.newThread())
// .throttleLast(200, TimeUnit.MILLISECONDS,Schedulers.newThread())
// .throttleFirst(200, TimeUnit.MILLISECONDS,Schedulers.newThread())
.subscribe(o -> System.out.print(o + "\t"))