Rjava操作符API

最新推荐文章于 2023-08-25 19:51:44 发布
最新推荐文章于 2023-08-25 19:51:44 发布
阅读量197 收藏
点赞数 1
文章标签： java android android studio
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fry3309/article/details/119648982
版权

1. 创建操作符

名称

有什么用

怎么用

create()

创建一个被观察者

Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {

@Override

public void subscribe(ObservableEmitter<String> e) throws Exception {

e.onNext("Hello Observer");

e.onComplete();

}

});

just()

创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。

Observable.just(1, 2, 3)

.subscribe(new Observer < Integer > () {

......................

});

formFuture()

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

FutureTask < String > futureTask = new FutureTask < > (new Callable < String > () {

@Override

public String call() throws Exception {

Log.d(TAG, "CallableDemo is Running");

return "返回结果";

}

});

Observable.fromFuture(futureTask)

.doOnSubscribe(new Consumer < Disposable > () {

@Override

public void accept(Disposable disposable) throws Exception {

futureTask.run();

}

})

.subscribe(new Consumer < String > () {

@Override

public void accept(String s) throws Exception {

Log.d(TAG, "================accept " + s);

}

});

formIterable()

直接发送一个 List 集合数据给观察者

List<Integer> list = new ArrayList<>();

list.add(0);

list.add(1);

list.add(2);

list.add(3);

Observable.fromIterable(list)

.subscribe(new Observer < Integer > () {

.................

});

formFuture()

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

FutureTask < String > futureTask = new FutureTask < > (new Callable < String > () {

@Override

public String call() throws Exception {

Log.d(TAG, "CallableDemo is Running");

return "返回结果";

}

});

Observable.fromFuture(futureTask)

.doOnSubscribe(new Consumer < Disposable > () {

@Override

public void accept(Disposable disposable) throws Exception {

futureTask.run();

}

})

.subscribe(new Consumer < String > () {

@Override

public void accept(String s) throws Exception {

Log.d(TAG, "================accept " + s);

}

});

formIterable()

直接发送一个 List 集合数据给观察者

List<Integer> list = new ArrayList<>();

list.add(0);

list.add(1);

list.add(2);

list.add(3);

Observable.fromIterable(list)

.subscribe(new Observer < Integer > () {

.................

});

defer()

这个方法的作用就是直到被观察者被订阅后才会创建被观察者。

// i 要定义为成员变量

Integer i = 100;

Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {

@Override

public ObservableSource<? extends Integer> call() throws Exception {

return Observable.just(i);

}

});

i = 200;

Observer observer = new Observer<Integer>() {

@Override

public void onSubscribe(Disposable d) {

}

@Override

public void onNext(Integer integer) {

Log.d(TAG, "================onNext " + integer);

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

}

};

observable.subscribe(observer);

i = 300;

observable.subscribe(observer);

----------------------------------------结果--------------------------------------------

05-20 20:05:01.443 26622-26622/? D/chan: ================onNext 200

================onNext 300

因为 defer() 只有观察者订阅的时候才会创建新的被观察者，所以每订阅一次就会打印一次，并且都是打印 i 最新的值。

timer()

当到指定时间后就会发送一个 0L 的值给观察者。

Observable.timer(2, TimeUnit.SECONDS)

.subscribe(new Observer < Long > () {

.................................

});

interval()

每隔一段时间就会发送一个事件，这个事件是从0开始，不断增1的数字。

Observable.interval(4, TimeUnit.SECONDS)

.subscribe(new Observer < Long > () {

......................

});

intervalRange()

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

// 从2，传入5个数，初始延迟2s，onNext延迟1s

Observable.intervalRange(2, 5, 2, 1, TimeUnit.SECONDS)

.subscribe(new Observer < Long > () {

...........................

});

range()

同时发送一定范围的事件序列。

从2到5

Observable.range(2, 5)

.subscribe(new Observer < Integer > () {

.................................

});

rangeLong()

同时发送一定范围的事件序列。

用法与 range() 一样

empty()

never()

error()

1. empty() ： 直接发送 onComplete() 事件

2. never()：不发送任何事件

3. error()：发送 onError() 事件

Observable.empty()

.subscribe(new Observer < Object > () {

.............................

});

打印结果：

==================onSubscribe

==================onComplete

复制代码

换成 never() 的打印结果：

==================onSubscribe

复制代码

换成 error() 的打印结果：

==================onSubscribe

==================onError java.lang.NullPointerException

2. 转换操作符

名称

有什么用

怎么用

map()

map 可以将被观察者发送的数据类型转变成其他的类型

Observable.just(1, 2, 3)

.map(new Function < Integer, String > () {

@Override

public String apply(Integer integer) throws Exception {

return "I'm " + integer;

}

})

.subscribe(new Observer < String > () {

............................................

});

flatMap(）

这个方法可以将事件序列中的元素进行整合加工，返回一个新的被观察者。

flatMap() 其实与 map() 类似，但是 flatMap() 返回的是一个 Observerable

.......................

同时发送一定范围的事件序列。

用法与 range() 一样

concatMap()

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

.............................

同时发送一定范围的事件序列。

用法与 range() 一样

buffer()

从需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区当中一并发出。

buffer 有两个参数，一个是 count，另一个 skip。count 缓冲区元素的数量，skip 就代表缓冲区满了之后，发送下一次事件序列的时候要跳过多少元素。这样说可能还是有点抽象，直接看代码：

Observable.just(1, 2, 3, 4, 5)

.buffer(2, 1)

.subscribe(new Observer < List < Integer >> () {

.................................

@Override

public void onNext(List < Integer > integers) {

Log.d(TAG, "================缓冲区大小： " + integers.size());

for (Integer i: integers) {

Log.d(TAG, "================元素： " + i);

}

}

.................................

});

-----------------------------打印结果----------------------------------------

================缓冲区大小： 2

================元素： 1

================元素： 2

================缓冲区大小： 2

================元素： 2

================元素： 3

================缓冲区大小： 2

================元素： 3

================元素： 4

================缓冲区大小： 2

================元素： 4

================元素： 5

================缓冲区大小： 1

================元素： 5

从结果可以看出，每次发送事件，指针都会往后移动一个元素再取值，直到指针移动到没有元素的时候就会停止取值。。

groupBy()

将发送的数据进行分组，每个分组都会返回一个被观察者。

Observable.just(5, 2, 3, 4, 1, 6, 8, 9, 7, 10)

.groupBy(new Function < Integer, Integer > () {

@Override

public Integer apply(Integer integer) throws Exception {

return integer % 3;

}

})

.subscribe(new Observer < GroupedObservable < Integer, Integer >> () {

................................

@Override public void onNext(GroupedObservable < Integer, Integer > integerIntegerGroupedObservable) {

................................

}

});

scan()

将数据以一定的逻辑聚合起来。

bservable.just(1, 2, 3, 4, 5)

.scan(new BiFunction < Integer, Integer, Integer > () {

@Override

public Integer apply(Integer integer, Integer integer2) throws Exception {

Log.d(TAG, "====================apply ");

Log.d(TAG, "====================integer " + integer);

Log.d(TAG, "====================integer2 " + integer2);

return integer + integer2;

}

})

.subscribe(new Consumer < Integer > () {

@Override

public void accept(Integer integer) throws Exception {

Log.d(TAG, "====================accept " + integer);

}

});

====================accept 1

====================apply

====================integer 1

====================integer2 2

====================accept 3

====================apply

====================integer 3

====================integer2 3

====================accept 6

====================apply

====================integer 6

====================integer2 4

====================accept 10

====================apply

====================integer 10

====================integer2 5

====================accept 15

window()

发送指定数量的事件时，就将这些事件分为一组。window 中的 count 的参数就是代表指定的数量，例如将 count 指定为2，那么每发2个数据就会将这2个数据分成一组。

Observable.just(1, 2, 3, 4, 5)

.window(2)

.subscribe(new Observer < Observable < Integer >> () {

................................

@Override

public void onNext(Observable < Integer > integerObservable) {

integerObservable.subscribe(new Observer < Integer > () {

@Override

public void onSubscribe(Disposable d) {

Log.d(TAG, "=====================integerObservable onSubscribe ");

}

@Override

public void onNext(Integer integer) {

Log.d(TAG, "=====================integerObservable onNext " + integer);

}

@Override

public void onError(Throwable e) {

Log.d(TAG, "=====================integerObservable onError ");

}

@Override

public void onComplete() {

Log.d(TAG, "=====================integerObservable onComplete ");

}

});

}

................................

});

---------------------打印结果----------------------

=====================integerObservable onSubscribe

=====================integerObservable onNext 1

=====================integerObservable onNext 2

=====================integerObservable onComplete

=====================integerObservable onSubscribe

=====================integerObservable onNext 3

=====================integerObservable onNext 4

=====================integerObservable onComplete

=====================integerObservable onSubscribe

=====================integerObservable onNext 5

=====================integerObservable onComplete

3. 条件操作符

all()

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

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

.all(new Predicate < Integer > () {

@Override

public boolean test(Integer integer) throws Exception {

return integer < 5;

}

}

..........................

--------------- 打印结果 --------------

==================aBoolean true

takeWhile()

可以设置条件，当某个数据满足条件时就会发送该数据，反之则不发送。

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

.takeWhile(new Predicate < Integer > () {

@Override

public boolean test(Integer integer) throws Exception {

return integer < 3;

}

})

.............................................

--------------- 打印结果 --------------

========================integer 1

========================integer 2

skipWhile()

可以设置条件，当某个数据满足条件时不发送该数据，反之则发送。

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

.skipWhile(new Predicate < Integer > () {

@Override

public boolean test(Integer integer) throws Exception {

return integer < 3;

}

})

.............................................

--------------- 打印结果 --------------

========================integer 3

========================integer 4

takeUntil()

可以设置条件，当事件满足此条件时，下一次的事件就不会被发送了。

Observable.just(1, 2, 3, 4, 5, 6)

.takeUntil(new Predicate < Integer > () {

@Override

public boolean test(Integer integer) throws Exception {

return integer > 3;

}

})

....................

--------------- 打印结果 --------------

========================integer 1

========================integer 2

skipUntil()

当 skipUntil() 中的 Observable 发送事件了，原来的 Observable 才会发送事件给观察者。

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

Observable.intervalRange(1, 5, 0, 1, TimeUnit.SECONDS)

.skipUntil(Observable.intervalRange(6, 5, 3, 1, TimeUnit.SECONDS))

..................................................

--------------- 打印结果 --------------

========================onSubscribe

========================onNext 4

========================onNext 5

========================onComplete

skipUntil() 里的 Observable 并不会发送事件给观察者。

sequenceEqual()

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

Observable.just(1, 2, 3)

.contains(3)

..................................

--------------- 打印结果 --------------

========================onNext true

isEmpty()

判断事件序列是否为空。

Observable.create(new ObservableOnSubscribe < Integer > () {

@Override

public void subscribe(ObservableEmitter < Integer > e) throws Exception {

e.onComplete();

}

})

.isEmpty()

................................

--------------- 打印结果 --------------

===================onNext true

amb()

amb() 要传入一个 Observable 集合，但是只会发送最先发送事件的 Observable 中的事件，其余 Observable 将会被丢弃。

ArrayList < Observable < Long >> list = new ArrayList < > ();

list.add(Observable.intervalRange(1, 5, 2, 1, TimeUnit.SECONDS));

list.add(Observable.intervalRange(6, 5, 0, 1, TimeUnit.SECONDS));

Observable.amb(list)

...................................

--------------- 打印结果 --------------

========================aLong 6

========================aLong 7

========================aLong 8

========================aLong 9

========================aLong 10

defaultIfEmpty()

如果观察者只发送一个 onComplete() 事件，则可以利用这个方法发送一个值。

Observable.create(new ObservableOnSubscribe < Integer > () {

@Override

public void subscribe(ObservableEmitter < Integer > e) throws Exception {

e.onComplete();

}

})

.defaultIfEmpty(666)

.......................

--------------- 打印结果 --------------

==================onNext 666

4. 组合操作符

名称

有什么用

怎么用

concat()

可以将多个观察者组合在一起，然后按照之前发送顺序发送事件。需要注意的是，concat() 最多只可以发送4个事件。

Observable.concat(Observable.just(1, 2),

Observable.just(3, 4),

Observable.just(5, 6),

Observable.just(7, 8))

.subscribe(new Observer < Integer > () {

...........................................................

});

concatArray()

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

........................................

merge()

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

只有等到第一个被观察者发送完事件之后，第二个被观察者才会发送事件。

mergeArray() 与 merge() 的作用是一样的，只是它可以发送4个以上的被观察者

conctArrayDelayError() & mergeArrayDelayError()

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

Observable.concatArrayDelayError(

Observable.create(new ObservableOnSubscribe < Integer > () {

@Override

public void subscribe(ObservableEmitter < Integer > e) throws Exception {

e.onNext(1);

e.onError(new NumberFormatException());

}

}), Observable.just(2, 3, 4))

.subscribe(new Observer < Integer > () {

@Override

public void onNext(Integer integer) {

Log.d(TAG, "===================onNext " + integer);

}

............................

});

---------------------打印结果----------------------

===================onNext 1

===================onNext 2

===================onNext 3

===================onNext 4

===================onError

zip()

会将多个被观察者合并，根据各个被观察者发送事件的顺序一个个结合起来，最终发送的事件数量会与源 Observable 中最少事件的数量一样。

Observable.zip(Observable.intervalRange(1, 5, 1, 1, TimeUnit.SECONDS)

.map(new Function<Long, String>() {

@Override

public String apply(Long aLong) throws Exception {

String s1 = "A" + aLong;

Log.d(TAG, "===================A 发送的事件 " + s1);

return s1;

}}),

Observable.intervalRange(1, 6, 1, 1, TimeUnit.SECONDS)

.map(new Function<Long, String>() {

@Override

public String apply(Long aLong) throws Exception {

String s2 = "B" + aLong;

Log.d(TAG, "===================B 发送的事件 " + s2);

return s2;

}

}),

new BiFunction<String, String, String>() {

@Override

public String apply(String s, String s2) throws Exception {

String res = s + s2;

return res;

}

})

.subscribe(new Observer<String>() {

.................................

});

---------------------打印结果----------------------

===================onSubscribe

===================A 发送的事件 A1

===================B 发送的事件 B1

===================onNext A1B1

===================A 发送的事件 A2

===================B 发送的事件 B2

===================onNext A2B2

===================A 发送的事件 A3

===================B 发送的事件 B3

===================onNext A3B3

===================A 发送的事件 A4

===================B 发送的事件 B4

===================onNext A4B4

===================A 发送的事件 A5

===================B 发送的事件 B5

===================onNext A5B5

===================onComplete

可以发现最终接收到的事件数量是5，那么为什么第二个 Observable 没有发送第6个事件呢？因为在这之前第一个 Observable 已经发送了 onComplete 事件，所以第二个 Observable 不会再发送事件。

combineLatest()

combineLatestDelayError()

combineLatest() 的作用与 zip() 类似，但是 combineLatest() 发送事件的序列是与发送的时间线有关的，当 combineLatest() 中所有的 Observable 都发送了事件，只要其中有一个 Observable 发送事件，这个事件就会和其他 Observable 最近发送的事件结合起来发送，这样可能还是比较抽象，看看以下例子代码。

上面代码

当发送 A1 事件之后，因为 B 并没有发送任何事件，所以根本不会发生结合。当 B 发送了 B1 事件之后，就会与 A 最近发送的事件 A2 结合成 A2B1，这样只有后面一有被观察者发送事件，这个事件就会与其他被观察者最近发送的事件结合起来了。

因为 combineLatestDelayError() 就是多了延迟发送 onError() 功能

reduce()

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

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

.reduce(new BiFunction < Integer, Integer, Integer > () {

@Override

public Integer apply(Integer integer, Integer integer2) throws Exception {

int res = integer + integer2;

Log.d(TAG, "====================integer " + integer);

Log.d(TAG, "====================integer2 " + integer2);

Log.d(TAG, "====================res " + res);

return res;

}

})

.subscribe(new Consumer < Integer > () {

@Override

public void accept(Integer integer) throws Exception {

Log.d(TAG, "==================accept " + integer);

}

});

---------------- 结果 ---------------------

====================integer 0

====================integer2 1

====================res 1

====================integer 1

====================integer2 2

====================res 3

====================integer 3

====================integer2 3

====================res 6

==================accept 6

collect()

将数据收集到数据结构当中。

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

.collect(new Callable < ArrayList < Integer >> () {

@Override

public ArrayList < Integer > call() throws Exception {

return new ArrayList < > ();

}

},

new BiConsumer < ArrayList < Integer > , Integer > () {

@Override

public void accept(ArrayList < Integer > integers, Integer integer) throws Exception {

integers.add(integer);

}

})

.subscribe(new Consumer < ArrayList < Integer >> () {

@Override

public void accept(ArrayList < Integer > integers) throws Exception {

Log.d(TAG, "===============accept " + integers);

}

});

---------------------结果------------------------

===============accept [1, 2, 3, 4]

startWith()

 startWithArray()

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

Observable.just(5, 6, 7)

.startWithArray(2, 3, 4)

.startWith(1)

.subscribe(new Consumer < Integer > () {

@Override

public void accept(Integer integer) throws Exception {

Log.d(TAG, "================accept " + integer);

}

});

---------------------结果-------------------

================accept 1

================accept 2

================accept 3

================accept 4

================accept 5

================accept 6

================accept 7

count()

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

Observable.just(1, 2, 3)

.count()

.subscribe(new Consumer < Long > () {

@Override

public void accept(Long aLong) throws Exception {

Log.d(TAG, "=======================aLong " + aLong);

}

});

--------------- 打印结果 ---------------

=======================aLong 3

5. 功能操作符

名称

有什么用

怎么用

delay()

延迟一段事件发送事件。

Observable.just(1, 2, 3)

//延迟了两秒才发送事件

.delay(2, TimeUnit.SECONDS)

.subscribe(new Observer < Integer > () {

.....................................................

});

doOnEach()

Observable 每发送一件事件之前都会先回调这个方法。

Observable.create(new ObservableOnSubscribe < Integer > () {

@Override

public void subscribe(ObservableEmitter < Integer > e) throws Exception {

e.onNext(1);

.............................

e.onComplete();

}

})

.doOnEach(new Consumer < Notification < Integer >> () {

@Override

public void accept(Notification < Integer > integerNotification) throws Exception {

Log.d(TAG, "==================doOnEach " + integerNotification.getValue());

}

})

.subscribe(new Observer < Integer > () {

........

});

---------------------- 打印结果 ----------------------

==================onSubscribe

==================doOnEach 1

==================onNext 1

==================doOnEach 2

==================onNext 2

==================doOnEach 3

==================onNext 3

==================doOnEach null

==================onComplete

doOnNext()

Observable 每发送 onNext() 之前都会先回调这个方法。

代码同上，不一样的是

.doOnNext(new Consumer < Integer > () {

@Override

public void accept(Integer integer) throws Exception {

Log.d(TAG, "==================doOnNext " + integer);

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================doOnNext 1

==================onNext 1

==================doOnNext 2

==================onNext 2

==================doOnNext 3

==================onNext 3

==================onComplete

doAfterNext()

Observable 每发送 onNext() 之后都会回调这个方法。

代码同上，不一样的是

.doAfterNext(new Consumer < Integer > () {

@Override

public void accept(Integer integer) throws Exception {

Log.d(TAG, "==================doAfterNext " + integer);

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================doAfterNext 1

==================onNext 2

==================doAfterNext 2

==================onNext 3

==================doAfterNext 3

==================onComplete

doOnComplete()

Observable 每发送 onComplete() 之前都会回调这个方法。

代码同上，不一样的是

.doOnComplete(new Action() {

@Override

public void run() throws Exception {

Log.d(TAG, "==================doOnComplete ");

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================doOnComplete

==================onComplete

doOnError()

Observable 每发送 onError() 之前都会回调这个方法。

代码同上，不一样的是

.doOnError(new Consumer < Throwable > () {

@Override

public void accept(Throwable throwable) throws Exception {

Log.d(TAG, "==================doOnError " + throwable);

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================doOnError java.lang.NullPointerException

==================onError

doOnSubscribe()

Observable 每发送 onSubscribe() 之前都会回调这个方法。

代码同上，不一样的是

.doOnSubscribe(new Consumer < Disposable > () {

@Override

public void accept(Disposable disposable) throws Exception {

Log.d(TAG, "==================doOnSubscribe ");

}

})

---------------------- 打印结果 ----------------------

==================doOnSubscribe

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onComplete

doOnDispose()

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

代码同上，不一样的是

.doOnDispose(new Action() {

@Override

public void run() throws Exception {

Log.d(TAG, "==================doOnDispose ");

}

})

.subscribe(new Observer < Integer > () {

private Disposable d;

@Override

public void onSubscribe(Disposable d) {

Log.d(TAG, "==================onSubscribe ");

this.d = d;

}

@Override

public void onNext(Integer integer) {

Log.d(TAG, "==================onNext " + integer);

d.dispose();

}

...............................................

});

---------------------- 打印结果 ----------------------

==================doOnSubscribe

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onComplete

doOnLifecycle()

在回调 onSubscribe 之前回调该方法的第一个参数的回调方法，可以使用该回调方法决定是否取消订阅。

代码同上，不一样的是

.doOnLifecycle(new Consumer<Disposable>() {

@Override

public void accept(Disposable disposable) throws Exception {

Log.d(TAG, "==================doOnLifecycle accept");

}

}, new Action() {

@Override

public void run() throws Exception {

Log.d(TAG, "==================doOnLifecycle Action");

}

})

.doOnDispose(

new Action() {

@Override

public void run() throws Exception {

Log.d(TAG, "==================doOnDispose Action");

}

})

.subscribe(new Observer<Integer>() {

private Disposable d;

@Override

public void onSubscribe(Disposable d) {

Log.d(TAG, "==================onSubscribe ");

this.d = d;

}

@Override

public void onNext(Integer integer) {

Log.d(TAG, "==================onNext " + integer);

d.dispose();

}

...............................................

});

---------------------- 打印结果 ----------------------

==================doOnLifecycle accept

==================onSubscribe

==================onNext 1

==================doOnDispose Action

==================doOnLifecycle Action

doOnTerminate() doAfterTerminate()

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

代码同上，不一样的是

.doOnTerminate(new Action() {

@Override

public void run() throws Exception {

Log.d(TAG, "==================doOnTerminate ");

}

})

.doAfterTerminate (new Action() {

@Override

public void run() throws Exception {

Log.d(TAG, "==================doAfterTerminate ");

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================doOnTerminate

==================onComplete

==================doAfterTerminate

doFinally()

在所有事件发送完毕之后回调该方法。

代码同上，不一样的是

.doFinally(new Action() {

@Override

public void run() throws Exception {

Log.d(TAG, "==================doFinally ");

}

})

.doOnDispose()

.doAfterTerminate()

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================doOnDispose

==================doFinally

doAfterTerminate() 已经成功回调，doFinally() 还是会在事件序列的最后。

onErrorReturn()

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

Observable.create(new ObservableOnSubscribe<Integer>() {

@Override

public void subscribe(ObservableEmitter<Integer> e) throws Exception {

e.onNext(1);

e.onNext(2);

e.onNext(3);

e.onError(new NullPointerException());

}

})

.onErrorReturn(new Function<Throwable, Integer>() {

@Override

public Integer apply(Throwable throwable) throws Exception {

Log.d(TAG, "==================onErrorReturn " + throwable);

return 404;

}

})

.subscribe(new Observer<Integer>() {

...........................................

});

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onErrorReturn java.lang.NullPointerException

==================onNext 404

==================onComplete

 onErrorResumeNext()

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

代码同上，不一样的是

.onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {

@Override

public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {

Log.d(TAG, "==================onErrorResumeNext " + throwable);

return Observable.just(4, 5, 6);

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onErrorResumeNext java.lang.NullPointerException

==================onNext 4

==================onNext 5

==================onNext 6

==================onComplete

onExceptionResumeNext()

与 onErrorResumeNext() 作用基本一致，但是这个方法只能捕捉 Exception。不能捕获new Error("404"))

Observable.create(new ObservableOnSubscribe<Integer>() {

@Override

public void subscribe(ObservableEmitter<Integer> e) throws Exception {

e.onNext(1);

e.onNext(2);

e.onNext(3);

e.onError(new Error("404"));

}

})

.onExceptionResumeNext(new Observable<Integer>() {

@Override

protected void subscribeActual(Observer<? super Integer> observer) {

observer.onNext(333);

observer.onComplete();

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onError

观察者收到 onError() 事件，证明 onErrorResumeNext() 不能捕捉 Error 事件。

将被观察者的 e.onError(new Error("404")) 改为 e.onError(new Exception("404"))，现在看看是否能捕捉 Exception 事件：

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onNext 333

==================onComplete

retry()

如果出现错误事件，则会重新发送所有事件序列。times 是代表重新发的次数。

代码同上，不一样的是（retry(代表重新发的次数)）

.retry(2)

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onNext 1

==================onNext 2

==================onNext 3

==================onNext 1

==================onNext 2

==================onNext 3

==================onError

retryUntil()

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

代码同上，不一样的是

.retryUntil(new BooleanSupplier() {

@Override

public boolean getAsBoolean() throws Exception {

if (i == 6) {

return true;

}

return false;

}

})

---------------------- 打印结果 ----------------------

==================onSubscribe

==================onNext 2

==================onNext 3

==================onError

retryWhen()

当被观察者接收到异常或者错误事件时会回调该方法，这个方法会返回一个新的被观察者。如果返回的被观察者发送 Error 事件则之前的被观察者不会继续发送事件，如果发送正常事件则之前的被观察者会继续不断重试发送事件。

Observable.create(new ObservableOnSubscribe < String > () {

@Override

public void subscribe(ObservableEmitter < String > e) throws Exception {

e.onNext("chan");

e.onNext("ze");

e.onNext("de");

e.onError(new Exception("404"));

e.onNext("haha");

}

})

.retryWhen(new Function < Observable < Throwable > , ObservableSource <? >> () {

@Override

public ObservableSource <? > apply(Observable < Throwable > throwableObservable) throws Exception {

return throwableObservable.flatMap(new Function < Throwable, ObservableSource <? >> () {

@Override

public ObservableSource <? > apply(Throwable throwable) throws Exception {

if(!throwable.toString().equals("java.lang.Exception: 404")) {

return Observable.just("可以忽略的异常");

} else {

return Observable.error(new Throwable("终止啦"));

}

}

});

}

})

--------------- 打印结果 ---------------

==================onSubscribe

==================onNext ze

==================onNext de

==================onError java.lang.Throwable: 终止啦

将 onError(new Exception("404")) 改为 onError(new Exception("303")) 看看打印结果：

==================onNext chan

==================onNext ze

==================onNext de

==================onNext chan

==================onNext ze

==================onNext de

==================onNext chan

......从结果可以看出，会不断重复发送消息。

repeat()

重复发送被观察者的事件，times 为发送次数。

Observable.create(new ObservableOnSubscribe < Integer > () {

@Override

public void subscribe(ObservableEmitter < Integer > e) throws Exception {

e.onNext(1);

e.onNext(2);

e.onNext(3);

e.onComplete();

}

})

.repeat(2)

--------------- 打印结果 ---------------

===================onSubscribe

===================onNext 1

===================onNext 2

===================onNext 3

===================onNext 1

===================onNext 2

===================onNext 3

===================onComplete

repeatWhen()

这个方法可以会返回一个新的被观察者设定一定逻辑来决定是否重复发送事件。

Observable.create(new ObservableOnSubscribe < Integer > () {

.....................

e.onNext(1);

e.onNext(2);

e.onNext(3);

e.onComplete();

})

.repeatWhen(new Function < Observable < Object > , ObservableSource <? >> () {

@Override

public ObservableSource <? > apply(Observable < Object > objectObservable) throws Exception {

return Observable.empty();

// return Observable.error(new Exception("404"));

// return Observable.just(4); null;

}

})

--------------- 打印结果 ---------------

===================onSubscribe

===================onComplete

直接看看发送 onError 事件和其他事件的打印结果。

发送 onError 打印结果：

===================onSubscribe

===================onError

发送其他事件的打印结果：

===================onSubscribe

===================onNext 1

===================onNext 2

===================onNext 3

===================onComplete

subscribeOn()

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

subscribeOn()主要改变的是订阅的线程，即call()执行的线程;)

下面提到的“操作”包括产生事件、用操作符操作事件以及最终的通过 subscriber 消费事件；

只有第一subscribeOn() 起作用（所以多个 subscribeOn() 无意义）；

这个 subscribeOn() 控制从流程开始的第一个操作，直到遇到第一个 observeOn()；

observeOn() 可以使用多次，每个 observeOn() 将导致一次线程切换()，这次切换开始于这次 observeOn() 的下一个操作；

不论是 subscribeOn() 还是 observeOn()，每次线程切换如果不受到下一个 observeOn() 的干预，线程将不再改变，不会自动切换到其他线程。

observeOn()

指定观察者的线程，每指定一次就会生效一次。

调度器

作用

Schedulers.computation( )

用于使用计算任务，如事件循环和回调处理

Schedulers.immediate( )

当前线程

Schedulers.io( )

用于 IO 密集型任务，如果异步阻塞 IO 操作。

Schedulers.newThread( )

创建一个新的线程

AndroidSchedulers.mainThread()

Android 的 UI 线程，用于操作 UI。

6. 过滤操作符

filter()

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

Observable.just(1, 2, 3)

.filter(new Predicate < Integer > () {

@Override

public boolean test(Integer integer) throws Exception {

return integer < 2;

}

})

..........................

--------------- 打印结果 --------------

==================onSubscribe

==================onNext 1

==================onComplete 。

ofType()

可以过滤不符合该类型事件

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

.ofType(Integer.class)

.............................................

--------------- 打印结果 --------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onComplete

skip()

skipLast()

跳过正序某些事件，count 代表跳过事件的数量

skipLast() 作用也是跳过某些事件，不过它是用来跳过正序的后面的事件

Observable.just(1, 2, 3)

.skip(2)

.............................................

--------------- 打印结果 --------------

==================onSubscribe

==================onNext 3

==================onComplete

distinct()

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

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

.distinct()

....................

--------------- 打印结果 --------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onComplete

distinctUntilChanged()

过滤掉连续重复的事件

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

.distinctUntilChanged()

..................................................

--------------- 打印结果 --------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onNext 2

==================onNext 1

==================onComplete

take()

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

Observable.just(1, 2, 3, 4, 5)

.take(3)

..................................

--------------- 打印结果 --------------

==================onSubscribe

==================onNext 1

==================onNext 2

==================onNext 3

==================onComplete

debounce()

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

throttleWithTimeout() 与此方法的作用一样

Observable.create(new ObservableOnSubscribe < Integer > () {

e.onNext(1);

Thread.sleep(900);

e.onNext(2);

}

.debounce(1, TimeUnit.SECONDS)

................................

--------------- 打印结果 --------------

===================onSubscribe

===================onNext 2

事件1并没有发送出去，现在将间隔时间改为1000

===================onSubscribe

===================onNext 1

===================onNext 2

firstElement() lastElement()

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

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

.firstElement()

...................................

==================onNext 1

.lastElement()

....................................

==================onNext 4

elementAt() elementAtOrError()

elementAt() 可以指定取出事件序列中事件，但是输入的 index 超出事件序列的总数的话就不会出现任何结果。这种情况下，你想发出异常信息的话就用 elementAtOrError() 。

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

//(下标)

.elementAtOrError(0)

.......................

==================onNext 1

小安雨
关注
Rxjava+Retrofit实现串行和并行网络请求功能
u014787504的博客
09-27 1万+
  现在越来越多的小伙伴使用RXJava了，Rxjava到底是什么呢？官方的api文档上的“异步”两个字揭漏了rxjava的本质，不错，他就是一个异步任务执行的方式，对于异步任务的具体理解可以参考之前的AsyncTask（当然仅仅是在概念上是一致的）。这个rxjava的作用主要就是通过构建Observable的对象实现对数据的操作，线程的灵活切换等。好了，废话不多说直接上代码。 第一步：我的a...
数据中台建设方案-基于大数据平台
2301_76549664的博客
03-14 2661
通过对客户大数据应用平台服务需求的理解，根据建设目标、设计原则的多方面考虑，建议采用星环科技Transwarp Data Hub（TDH）大数据基础平台的架构方案，基于Transwarp Operating System（简称TOS）云平台方式部署构建。 通过建立大数据集成平台、大数据计算平台、大数据开发平台及大数据运维平台来满足客户大数据应用平台服务建设的要求。
Rxjava操作符汇总
zhupumao的博客
07-17 2454
《RxJavaEssentials》笔记 参考博客：http://www.tuicool.com/articles/A3uY7rF。一、创建型操作符1. just()功能：将一个或多个对象转换成发射这个或这些对象的一个Observable。 用法：just= Observable.just(1,3,4).subscribe(new Subscriber<Integer>() {
RxJava 操作符
最新发布
u010498248的博客
08-25 629
在 RxJava 中，一个实现了 observer 接口的对象可以订阅 observable 类的实例。订阅者对 observable 发射的任何数据或者数据序列做出响应。这种模式简化了并发操作，因为它不需要阻塞等待 observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 observable 的通知。RxJava 提供了一套异步编程的 API ，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁。
RxJava的初步使用
yuemingxingxing的博客
07-04 157
1.普通订阅 Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() { @Override public void subscribe(ObservableEmitter<String> em...
RxJava 知识梳理(2) RxJava2 操作符实战
weixin_34212762的博客
12-21 121
一、概述 本文中的所有示例均来自RxJava2这个大神的仓库，这两篇文章主要是对示例当中的用法进行一个记录，方便以后进行查询。 二、详细示例 2.1 SimpleExampleActivity 这是一个最简单的例子，被订阅者发射了两个数据（Cricket、Football），并且有一个订阅者，发生订阅时，会先回调onSubscribe(Disposable d)，发射数据后，回调onNext(St...
rx java操作符_RxJava 常用操作符大全（一）
weixin_26812607的博客
02-13 851
这里写图片描述createcreate操作符是所有创建型操作符的“根”，也就是说其他创建型操作符最后都是通过create操作符来创建Observable的调用例子如下：Observable.create(new Observable.OnSubscribe() {@Overridepublic void call(Subscriber super Integer> observer) {tr...
RSQLServer：基于jTDS驱动程序的RSQL Server DBI
02-05
例如，你可以使用`tbl()`函数创建一个数据库表的远程引用，然后使用`dplyr`的管道操作符 `%>%` 进行查询： ```r data (con, "your_table") %>% filter(column_name > some_value) %>% select(column1, column2) %...
通过命令行实现Android工程资源文件到apk的流程
linghuanyun的博客
09-27 1445
通过命令行实现Android工程资源文件到apk的流程 相关工具地址 创建Android工程文件 生成Rjava 编译java2class class2dex 打包资源文件 生成未签名的apk 生成签名秘钥 apk签名 异常总结
中文分词软件包的使用
qianwenhong
12-10 1万+
中文分词 (Chinese Word Segmentation) 指的是将一个汉字序列切分成一个一个单独的词。分词就是将连续的字序列按照一定的规范重新组合成词序列的过程。我们知道，在英文的行文中，单词之间是以空格作为自然分界符的，而中文只是字、句和段能通过明显的分界符来简单划界，唯独词没有一个形式上的分界符，虽然英文也同样存在短语的划分问题，不过在词这一层上，中文比之英文要复杂的多、困难的多。下面
RxDart学习笔记
jielundewode的专栏
07-01 2706
参考了以下文章，感谢他们的无私付出： https://www.jianshu.com/p/612d43c8915f https://juejin.im/post/5bcea438e51d4536c65d2232 Subject实现并扩展了StreamController,它符合StreamController的所有规范。假如您之前使用的StreamController,那么你可以直接替换为Su...
面试：Rxjava线程调度使用
王温暖的博客
12-13 1127
RxJava2线程调度使用： 最简单易懂的RxJava2.0学习教程之RxJava2的线程调度（二）_简简单单_zz的博客-优快云博客 使用RxJava的时候，在没有切换线程的情况下, 上游==被观察者(observable)和下游==观察者(observer)是工作在同一个线程中的,即都在主线程中。 话不多说上代码： Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Int
Carson带你学Android：RxJava创建操作符
Carson带你学Android
10-16 1万+
前言 Rxjava，由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。 如果还不了解 RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程 RxJava如此受欢迎的原因，在于其提供了丰富 & 功能强大的操作符，几乎能完成所有的功能需求 今天，我将为大家详细介绍RxJava操作符中最常用的创建操作符，并附带 Ret
RxJava2极速入门——Rxjava操作符详解之创建操作符
易庞宙的博客
03-22 1180
目录 RxJava操作符——创建操作符 create操作符 defer操作符 from操作符 fromArray操作符 fromIterable操作符 fromFuture操作符 interval操作符 just操作符 range操作符 repeat操作符 repeat操作符分析 repeatWhen操作符 repeatUntil操作符 timer操作符 empty...
RxJava 1.x from()和just()用法、区别和举例
王洪伟的专栏
07-01 5374
RxJava 1.x 中的 Observable.from 和 Observable.just 用于将Java 面向对象中的数据转换为 RxJava 中的数据单元。一、fromRxJava 1.x 包含了5个 Observable.from 的重载方法：public static <T> Observable<T> from(Iterable <? extends T> iterable)publi
【安卓】rxjava2的disposable
热门推荐
Zoom
12-11 2万+
rxjava+retrofit处理网络请求 在使用rxjava+retrofit处理网络请求的时候，一般会采用对观察者进行封装，实现代码复用和拓展。可以参考我的这篇文章：rxjava2+retrofit封装处理网络请求全解析。一种可行的封装如下： 基类observer public abstract class BaseObserver&amp;lt;T&amp;gt; implements Obser...
RxJava2.x 创建操作符之 from
「程序员飞飞」的博客
05-19 1928
题图：Pixabay License 哈喽，朋友们，上一篇文章我们学习了 create & just 操作符，今天我们继续来学习 from 操作符。 from 操作符和 just 操作符一样，也属于创建操作符的一种，from 可将其他种类的对象和数据类型转换为 Observable。 从概念看，just 和 from 是比较相似的，那么，他们两者有什么区别呢？ just 只是简单的原样发...
深入分析RxJava的Disposable及其工作原理
移动端开发干货分享
01-10 5753
良好的编码习惯告诉我们，任何基于订阅者模式代码，都要注意为注册与注销的配对出现，以避免泄露都问题 Disposable RxJava通过Disposable（RxJava1中是Subscription）在适当的时机取消订阅、停止数据流的继续发射。这在Android等具有Lifecycle概念的case中非常重要，避免造成一些不必要的对象泄露与bug。 private CompositeDisposable compositeDisposable = new CompositeDisposab..
RxAndroid - 基础概念+基础实践讲解（一）
眼睛一闭一睁一天就过去了哼，眼睛一闭不睁一辈子就过去了哼。
03-06 478
看了一些网上rxjava教程，做了一些实践实例，自己从新手开始掌握rxjava，感谢前辈们的贡献。这里是我的学习记录，同时也想以最简洁最清晰最快速的方式为后来者引路。rxjava，响应式编程  - https://github.com/ReactiveX/RxJava          官方文档如 a = b * c ，b值变化了，a值自动变化，a监听订阅b的变化。b即为被观察者observabl...
RStudio中rjava包的安装与配置指南
- 安装过程中，请按照安装向导的提示进行操作，建议在安装过程中记住JDK的安装路径，因为配置`rjava`时可能会用到。 2. **配置环境变量：** - 安装完毕后，需要设置系统环境变量，包括JAVA_HOME和CLASSPATH。 -...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值