RxJava2总结之操作详解(二)

最新推荐文章于 2021-03-12 09:03:46 发布

Typist夫少

最新推荐文章于 2021-03-12 09:03:46 发布

阅读量4.6k

点赞数 4

文章标签： RxJava2

本文链接：https://blog.csdn.net/jackzhang_0522/article/details/77337086

版权

辅助操作

repeat

不是创建一个Observable,而是重复发射原始,Observable的数据序列，这个序列或者是无限的，或者通过 repeat(n) 指定重复次数

Observable.just("Love", "For", "You!")
          .repeat(3)//重复三次
          .subscribe(s -> System.out.println(s));

repeatUntil

getAsBoolean 如果返回 true则不repeat false则repeat.主要用于动态控制

Observable.just("Love", "For", "You!")
                .repeatUntil(new BooleanSupplier() {
                    @Override
                    public boolean getAsBoolean() throws Exception {
                        System.out.println("getAsBoolean");
                        count++;
                        if (count == 3)
                            return true;
                        else
                            return false;
                    }
                }).subscribe(s -> System.out.println(s));

delay

延迟一段指定的时间再发射来自Observable的发射物
注意：delay 不会平移 onError 通知，它会立即将这个通知传递给订阅者，同时丢弃任何待 发射的 onNext 通知。然而它会平移一个 onCompleted 通知

Observable.range(0, 3)
          .delay(1400, TimeUnit.MILLISECONDS)
          .subscribe(o -> System.out.println("===>" + o + "\t"));

delaySubscription

让你可以延迟订阅原始Observable

Observable.just(1)
                .delaySubscription(2000, TimeUnit.MILLISECONDS)
                .subscribe(o -> System.out.println("===>" + o + "\t")
                        , throwable -> System.out.println("===>throwable")
                        , () -> System.out.println("===>complete")
                        , disposable -> System.out.println("===>订阅"));

do系列

doOnEach

注册一个回调，它产生的Observable每发射一项数据就会调用它一次

Observable.range(0, 3)
              .doOnEach(integerNotification -> System.out.println(integerNotification.getValue()))
              .subscribe(o -> System.out.print("===>" + o + "\t"));
  日志:
  doOnEach:
  doOnEach:0===>0
  doOnEach:1===>1
  doOnEach:2===>2
  doOnEach:null

doOnNext

注类似doOnEach 不是接受一个 Notification 参数，而是接受发射的数据项。

 Observable.range(0, 3)
         .doOnNext(integer -> {
             if (integer == 2)
                 throw new Error("O__O");
             System.out.print(integer);
         })
         .subscribe(o -> System.out.print("===>" + o + "\t")
                 , throwable -> System.out.print("===>throwable")
                 , () -> System.out.print("===>complete"));
日志:
0===>0  1===>1  ===>throwable

doOnSubscribe

注册一个动作，在观察者订阅时使用

Observable.range(0, 3)
              .doOnSubscribe(disposable -> System.out.print("开始订阅"))
              .subscribe(o -> System.out.print("===>" + o + "\t"));
    日志:
     开始订阅===>0  ===>1   ===>2

doOnComplete

注册一个动作，在观察者OnComplete时使用

Observable.range(0, 3)
               .doOnComplete(() -> System.out.print("doOnComplete"))
               .subscribe(o -> System.out.print("===>" + o + "\t"));
   日志:
    ===>0   ===>1   ===>2   doOnComplete

doOnError

注册一个动作，在观察者doOnError时使用

Observable.error(new Throwable("?"))
               .doOnError(throwable -> System.out.print("throwable"))
               .subscribe(o -> System.out.print("===>" + o + "\t"));
  日志:
  异常信息....
  throwable

doOnTerminate

注册一个动作，Observable终止之前会被调用，无论是正 常还是异常终止。

Observable.range(0, 3)
         .doOnTerminate(() -> System.out.print("\t doOnTerminate"))
         .subscribe(o -> System.out.print("===>" + o + "\t"));
日志:
===>0   ===>1   ===>2        doOnTerminate

doFinally

注册一个动作,当它产生的Observable终止之后会被调用，无论是正常还 是异常终止。在doOnTerminate之后执行

Observable.range(0, 3)
                .doFinally(() -> System.out.print("\t doFinally"))
                .doOnTerminate(() -> System.out.print("\t  doOnTerminate"))
                .subscribe(o -> System.out.print("===>" + o + "\t"));
 日志:
 ===>0  ===>1   ===>2         doOnTerminate  doFinally

doOnDispose

注册一个动作,当【观察者取消】订阅它生成的Observable它就会被调
注意:貌似需要在 为出现complete和error的时候 dispose才会触发 ~

Disposable ab = Observable.interval(1, TimeUnit.SECONDS)
              .take(3)
              .doOnDispose(() -> System.out.println("解除订阅"))
              .subscribe(o -> System.out.print("===>" + o + "\t"));
      ab.dispose();
日志:
解除订阅

materialize

将数据项和事件通知都当做数据项发射

dematerialize

materialize相反

Observable.range(0, 3)
                //将Observable转换成一个通知列表。
                .materialize()
                //与上面的作用相反，将通知逆转回一个Observable
                .dematerialize()
                .subscribe(o -> System.out.print("===>" + o + "\t"));

observeOn

指定一个观察者在哪个调度器上观察这个Observable

subscribeOn

指定Observable自身在哪个调度器上执行
注意 遇到错误 会立即处理而不是等待下游还没观察的数据, 即onError 通知会跳到(并吞掉)原始Observable发射的数据项前面

Observable.range(0, 3)
              .subscribeOn(Schedulers.newThread())
              .observeOn(Schedulers.newThread())
              .subscribe(o -> System.out.print("===>" + o + "\t"));

操作来自Observable的发射物和通知

Javadoc: subscribe()
Javadoc: subscribe(onNext)
Javadoc: subscribe(onNext,onError)
Javadoc: subscribe(onNext,onError,onComplete)
Javadoc: subscribe(onNext,onError,onComplete,onSubscribe)
Javadoc: subscribe(Observer)
Javadoc: subscribe(Subscriber)

foreach

forEach 方法是简化版的 subscribe ，你同样可以传递一到三个函数给它，解释和传递给 subscribe 时一样. 
不同的是，你无法使用 forEach 返回的对象取消订阅。也没办法传递一个可以用于取消订阅 的参数

Observable.range(0, 3)
        //subscribe的简化版本  没啥用
        .forEach(o -> System.out.println("===>" + o + "\t"));

serialize

保证上游下游同一线程 ，防止不同线程下 onError 通知会跳到(并吞掉)原始Observable发射的数据项前面的错误行为

Observable.range(0, 3)
           .serialize()
           .subscribe(o -> System.out.print("===>" + o + "\t"));

Timestamp

它将一个发射T类型数据的Observable转换为一个发射类型 为Timestamped 的数据的Observable，每一项都包含数据的原始发射时间

Observable.interval(100, TimeUnit.MILLISECONDS)
               .take(3)
                .timestamp()
                .subscribe(o -> System.out.println("===>" + o + "\t")
                        , throwable -> System.out.println("===> throwable")
                        , () -> System.out.println("===> complete")
                        , disposable -> System.out.println("===> 订阅"));
    日志:
    ===> 订阅
    ===>Timed[time=1501224256554, unit=MILLISECONDS, value=0]
    ===>Timed[time=1501224256651, unit=MILLISECONDS, value=1]
    ===>Timed[time=1501224256751, unit=MILLISECONDS, value=2]
    ===> complete

timeInterval

一个发射数据的Observable转换为发射那些数据发射时间间隔的Observable

Observable.interval(100, TimeUnit.MILLISECONDS)
                .take(3)
//         把发送的数据 转化为  相邻发送数据的时间间隔实体
                .timeInterval()
//                .timeInterval(Schedulers.newThread())
                .subscribe(o -> System.out.println("===>" + o + "\t")
                        , throwable -> System.out.println("===>throwable")
                        , () -> System.out.println("===>complete")
                        , disposable -> System.out.println("===>订阅"));
    日志:
    ===>订阅
    ===>Timed[time=113, unit=MILLISECONDS, value=0]
    ===>Timed[time=102, unit=MILLISECONDS, value=1]
    ===>Timed[time=97, unit=MILLISECONDS, value=2]
    ===>complete

timeout

变体:过了一个指定的时长仍没有发射数据(不是仅仅考虑第一个)，它会发一个错误

Observable.interval(100, TimeUnit.MILLISECONDS)
//        过了一个指定的时长仍没有发射数据(不是仅仅考虑第一个)，它会发一个错误
                .timeout(50, TimeUnit.MILLISECONDS)
                .subscribe(o -> System.out.println("===>" + o + "\t")
                        , throwable -> System.out.println("===>timeout throwable")
                        , () -> System.out.println("===>timeout complete")
                        , disposable -> System.out.println("===>timeout 订阅"));
timeout:
===>timeout 订阅
===>timeout throwable

变体备用Observable:过了一个指定的时长仍没有发射数据(不是仅仅考虑第一个)，它会发一个错误

Observable<Integer> other;
Observable.empty()
         // 过了一个指定的时长仍没有发射数据(不是仅仅考虑第一个)，他会用备用Observable 发送数据，本身的会发送一个compelte
         .timeout(50, TimeUnit.MILLISECONDS, other = Observable.just(2, 3, 4))
         .subscribe(o -> System.out.println("===>" + o + "\t")
                 , throwable -> System.out.println("===>timeout2 throwable")
                 , () -> System.out.println("===>timeout2 complete")
                 , disposable -> System.out.println("===>timeout2 订阅"));
 other.subscribe(o -> System.out.println("k ===>" + o + "\t"));
timeout2:
===>timeout2 订阅
===>timeout2 complete
k ===>2
k ===>3
k ===>4

变换操作

map

对Observable发射的每一项数据应用一个函数，执行变换操作,就是方形过渡到圆形

Observable.just(1,2)
              .map(integer -> "This is result " + integer)
              .subscribe(s -> System.out.println(s));

flatMap

将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable

mapper:根据发射数据映射成Observable
combiner: 用来合并的

注意:FlatMap 对这些Observables发射的数据做的是合并( merge )操作，因此它们可能是交错的。

Observable.just(1, 2, 3)
        .flatMap(integer -> Observable.range(integer * 10, 2)
        , (a, b) -> {
                           //a ： 原始数据的 just(1,2,3) 中的值
                           //b ： 代表 flatMap后合并发送的数据的值
                           System.out.print("\n a:" + a + "\t b:" + b);
                           //return flatMap发送的值 ，经过处理后 而发送的值
                           return a + b;
                       })
               .subscribe(s -> System.out.print("\t"+s));
日志：
 <!-- 这里有顺序是因为没有在其他线程执行 -->
a:1  b:10   11
a:1  b:11   12
a:2  b:20   22
a:2  b:21   23
a:3  b:30   33
a:3  b:31   34

concatMap

类似FlatMap但是保证顺序 因为没有合并操作！

Observable.just(1, 2, 3)
            .concatMap(integer -> Observable.range(integer * 10, 2))
            .subscribe(s -> System.out.print("\t"+s));

cast

在发射之前强制将Observable发射的所有数据转换为指定类型

Observable.just(1, 2, "string")
               .cast(Integer.class)//订阅之后才能发横强转
               .subscribe(integer -> System.out.println(integer)
                       , throwable -> System.out.println(throwable.getMessage()));

groupBy

通过keySelector的apply的值当做key 进行分组,发射GroupedObservable(有getKey()方法)的group 通过group继续订阅取得其组内的值;

keySelector:通过这个的返回值当做key进行分组
valueSelector:value转换

Observable.range(0, 10)
                .groupBy(integer -> integer % 2, integer -> "(" + integer + ")")
                .subscribe(group -> {
                    group.subscribe(integer -> System.out.println(
                            "key:" + group.getKey() + "==>value:" + integer));
                });
日志：
key:0==>value:(0)
key:1==>value:(1)
key:0==>value:(2)
key:1==>value:(3)
key:0==>value:(4)
key:1==>value:(5)
key:0==>value:(6)
key:1==>value:(7)
key:0==>value:(8)
key:1==>value:(9)

window

依照此范例 每三秒收集,Observable在此时间内发送的值。组装成Observable发送出去。

Observable.interval(1, TimeUnit.SECONDS).take(7)
                //返回值  Observable<Observable<T>> 即代表 发送Observable<T>
                .window(3, TimeUnit.SECONDS)
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .subscribe(integerObservable -> {
                    System.out.println(integerObservable);
                    integerObservable.subscribe(integer -> System.out.println(integerObservable+"===>"+integer));
                });
日志:
为什么不是 345一起？ 因为会有太细微的时间差。例如5如果在多线程切换的时候是超过3秒的1毫秒则就尴尬了~
io.reactivex.subjects.UnicastSubject@531c3d1c
io.reactivex.subjects.UnicastSubject@531c3d1c===>0
io.reactivex.subjects.UnicastSubject@531c3d1c===>1
io.reactivex.subjects.UnicastSubject@531c3d1c===>2
io.reactivex.subjects.UnicastSubject@2ea0f969
io.reactivex.subjects.UnicastSubject@2ea0f969===>3
io.reactivex.subjects.UnicastSubject@2ea0f969===>4
io.reactivex.subjects.UnicastSubject@2d30de03
io.reactivex.subjects.UnicastSubject@2d30de03===>5
io.reactivex.subjects.UnicastSubject@2d30de03===>6

scan

连续地对数据序列的每一项应用一个函数，然后连续发射结果

感觉就是发送一个有累加(函数) 过程序列
* initialValue（可选）其实就是放到原始数据之前发射。
* a 原始数据的中的值
* b 则是最后应用scan函数后发送的值

Observable.just(1, 4, 2)
                //7是用来 对于第一次的 a的值
                .scan(7, (a, b) -> {
                    //b 原始数据的 just(1,4,2) 中的值
                    //a 则是最后应用scan 发送的值
                    System.out.format("a:%d * b:%d\n", a, b);
                    return a * b;
                })
                .subscribe(integer -> System.out.println("===>："+integer));
日志：
===>：7
a:7 * b:1
===>：7
a:7 * b:4
===>：28
a:28 * b:2
===>：56

buffer系列

buffer

变体 count系列

 1. 范例:发射[1-10]
 2. buffer count 2 skip 1,结果 [1,2]  [2,3] [3,4] 3=2*1+1
 3. buffer count 2 skip 2,结果 [1,2]  [3,4] [5,6] 5=2*2+1
 4. buffer count 2 skip 3,结果 [1,2]  [4,5] [7,8] 7=2*3+1;

1) count:缓存的数量
2) skip:每个缓存创建的间隔数量
这代表每次初始偏移量每次真正的起始值=fistValue+skip*skipCount;
注意skip不能小于0
可以小于count这样就会导致每个发送的list之间的值会有重复
可以大于count这样就会导致每个发送的list之间的值和原有的值之间会有遗漏
可以等于count就你懂的了
3) bufferSupplier:自定义缓存装载的容器

Observable.range(1, 10)
        .buffer(2, 1,() -> new ArrayList<>())//有默认的装载器
        <!-- 其他方法 -->
        <!-- .buffer(2)//skip 默认和count一样 -->
        <!--  .buffer(2, () -> new ArrayList<>())-->
        .subscribe(integers -> System.out.println(integers));
 解析:每发射1个。创建一个发射物list buffer,每个buffer缓存2个,收集的存入list后发送。

变体 time系列

1) timespan:缓存的时间
2) timeskip:每个缓存创建的间隔时间同skip 可以小于大于等于timespan

Observable.interval(500, TimeUnit.MILLISECONDS).take(7)
                .buffer(3, 2, TimeUnit.SECONDS, Schedulers.single(),
                        Functions.createArrayList(16))
                .subscribe(integers -> System.out.println(integers));
解析:每两秒创建一个发射物list buffer,每个buffer缓存三秒 收集的存入list后发送。
日志:
  [0, 1, 2, 3, 4]
  [4, 5, 6]

3) 变体自定义buffer创建和收集时间
4) bufferOpenings:每当 bufferOpenings 发射了一个数据时，它就创建一个新的 List,开始装入之后的发射数据
5) closingSelector:每当 closingSelector 发射了一个数据时,就结束装填数据发射List。

 <!-- 范例和time系列的就一样了 -->
 Consumer<Long> longConsumer = aLong -> System.out.println("开始创建 bufferSupplier");
        Consumer<Long> longConsumer2 = aLong -> System.out.println("结束收集");
        Observable.interval(500, TimeUnit.MILLISECONDS).take(7)
//                .doOnNext(aLong -> System.out.println("原始发射物：" + aLong))
                .buffer(Observable.interval(2, TimeUnit.SECONDS)
                                .startWith(-1L)//为了刚开始就发射一次
                                .take(2)//多余的我就不创建了
                                .doOnNext(longConsumer)
                        , aLong -> Observable.timer(3, TimeUnit.SECONDS)
                                .doOnNext(longConsumer2)
                        , () -> new ArrayList<>())
                .subscribe(integers -> System.out.println("buffer发射物" + integers));
日志:
openings:
开始创建 bufferSupplier
开始创建 bufferSupplier
结束收集
buffer发射物[0, 1, 2, 3, 4]
buffer发射物[4, 5, 6]

变体仅仅bufer创建时间

boundarySupplier 因为发送一个值代表上个缓存的发送和这个缓存的创建
*注释: 这个缓存是连续的, 因为发送一个值代表上个缓存的发送和这个缓存的创建
有发射物的时候没缓存就创建了就是默认第一个发射物的时候由内部创建
注意如果不发送事件缓存存满了会自动发送出去的

Observable.interval(500, TimeUnit.MILLISECONDS).take(7)
                .buffer(() -> Observable.timer(2, TimeUnit.SECONDS)
                                .doOnNext(aLong -> System.out.println("开始创建 bufferSupplier"))
                        , () -> new ArrayList<Object>())
                .subscribe(integers -> System.out.println(integers));
日志:
开始创建 bufferSupplier
[0, 1, 2]
[3, 4, 5, 6]

Typist夫少

关注

4
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
RxJava2总结之操作详解(二)

目录目录辅助操作repeatrepeatUntildelaydelaySubscriptiondo系列doOnEachdoOnNextdoOnSubscribedoOnCompletedoOnErrordoOnTerminatedoFinallydoOnDisposematerializedematerializeobserveOnsubscribeOnsubs
复制链接

扫一扫