RxJava2实战---第七章 合并操作符和连接操作符

RxJava的合并操作符:

  • startWith():在数据序列的开头增加一项数据。
  • merge:将多个Observable合并为一个。
  • mergeDelayError():合并多个Observable,让没有错误的Observable都完成后再发射错误通知。
  • zip():使用一个函数组合多个Observable发射的数据集合,然后再发射这个结果。
  • combineLatest():当两个Observable中的任何一个发射一个数据时,通知一个指定的函数组合每个Observable发射的最新数据(一共两个数据),然后在发射这个函数的结果。
  • **join(): **无论何时,如果一个Observable发射了一个数据项,就需要在另一个Observable发射的数据项定义的时间窗口内,将两个Observable发射的数据合并发射。
  • switchOnNext():将一个发射Observable的Observable转换成另一个Observable,后者发射这些Observable最近发射的数据。

RxJava的连续操作符,主要是ConnectableObservable所使用的操作符和Observable所使用的操作符。

  • ConnectableObservable.connect():指示一个可连续的Observable开始发射数据项。
  • Observable.publish():将一个Observable转换为一个可连续的Observable.
  • Observable.replay():确保所有的订阅者看到相同的数据序列,即使它们在Observable开始发射数据之后才订阅。
  • ConnectableObservable.reCount():让一个可连续的Observable表现得像一个普通的Observable。

合并操作符能够同时处理多个被观察者,并发送相应的事件。

对于连接操作符,有一个很重要的概念connectableObservable。可连接的Observable在被订阅时并不发射数据,只有在它的connect()被调用时才开始发射数据。

1. 合并操作符

1.1 startWith

在数据序列的开头插入一条指定的项

  1. Observable.just("Hello Java","Hello Kotlin","Hello Android")
  2. .startWith("Hello Rx")
  3. .subscribe(new Consumer<String>() {
  4. @Override
  5. public void accept(String s) throws Exception {
  6. System.out.println(s);
  7. }
  8. });
  9. //Lamand表达式
  10. Observable.just("Hello Java","Hello Kotlin","Hello Android")
  11. .startWith("Hello Rx")
  12. .subscribe(s -> System.out.println(s));
  13. 执行结果:
  14. Hello Rx
  15. Hello Java
  16. Hello Kotlin
  17. Hello Android

startWith操作符支持传递Iterable,同时还有一个startWithArray的操作符

使用了startWithArray操作符之后,可以再使用startWith操作符。

多次使用startWith操作符,最后发射的数据也永远排在最前面。

  1. Observable.just("Hello Java","Hello Kotlin","Hello Android")
  2. .startWithArray("Hello Rx","Hello Android")
  3. .startWith("Hello World")
  4. .subscribe(new Consumer<String>() {
  5. @Override
  6. public void accept(String s) throws Exception {
  7. System.out.println(s);
  8. }
  9. });
  10. //Lamand表达式
  11. Observable.just("Hello Java","Hello Kotlin","Hello Android")
  12. .startWithArray("Hello Rx","Hello RN")
  13. .startWith("Hello World")
  14. .subscribe(s -> System.out.println(s));
  15. 执行结果:
  16. Hello World
  17. Hello Rx
  18. Hello Android
  19. Hello Java
  20. Hello Kotlin
  21. Hello Android

startWith还可以传递一个Observable对象,它会将那个Observable的发射物插在原始Observable发射的数据序列之前,然后把这个当做自己的发射物集合。

  1. Observable.just("Hello Java","Hello Kotlin","Hello Android")
  2. .startWithArray("Hello Rx","Hello Android")
  3. .startWith(Observable.just("HellowWorld"))
  4. .subscribe(new Consumer<String>() {
  5. @Override
  6. public void accept(String s) throws Exception {
  7. System.out.println(s);
  8. }
  9. });
  10. //Lamand表达式
  11. Observable.just("Hello Java","Hello Kotlin","Hello Android")
  12. .startWithArray("Hello Rx","Hello RN")
  13. .startWith(Observable.just("HellowWorld"))
  14. .subscribe(s -> System.out.println(s));
  15. 执行结果:
  16. HellowWorld
  17. Hello Rx
  18. Hello Android
  19. Hello Java
  20. Hello Kotlin
  21. Hello Android

1.2 concat/concatArray

组合多个被观察者一起发送数据,合并后 按发送顺序串行执行

按发送顺序串行执行

concat最多连接4个,而concatArray可以连接多个。

  1. Observable.concatArray(Observable.intervalRange(1,3,0,1,TimeUnit.SECONDS)
  2. ,Observable.intervalRange(4,3,0,1,TimeUnit.SECONDS))
  3. .subscribe(new Consumer<Long>() {
  4. @Override
  5. public void accept(Long aLong) throws Exception {
  6. System.out.println(aLong);
  7. }
  8. });
  9. //lamand表达式
  10. Observable.concatArray(Observable.intervalRange(1,3,0,1,TimeUnit.SECONDS)
  11. ,Observable.intervalRange(4,3,0,1,TimeUnit.SECONDS))
  12. .subscribe(integer -> System.out.println(integer));
  13. 执行结果:
  14. 1
  15. 2
  16. 3
  17. 4
  18. 5
  19. 6

1.3 concatArrayDelayError/mergeArrayDelayError

使用concat和merge操作符时,如果遇到其中一个被观察者发出onError事件则会马上终止其他被观察者的事件,如果希望onError事件推迟到其他被观察者都结束后才触发,可以使用对应的concatArrayDelayError或者mergeArrayDelayError操作符

  1. Observable
  2. .concatArrayDelayError(
  3. Observable.create(new ObservableOnSubscribe<Integer>() {
  4. @Override
  5. public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
  6. emitter.onNext(1);
  7. emitter.onNext(2);
  8. emitter.onError(new NullPointerException());
  9. emitter.onNext(3);
  10. }
  11. }),
  12. Observable.just(4,5,6))
  13. .subscribe(new Consumer<Integer>() {
  14. @Override
  15. public void accept(Integer integer) throws Exception {
  16. System.out.println(integer);
  17. }
  18. }, new Consumer<Throwable>() {
  19. @Override
  20. public void accept(Throwable throwable) throws Exception {
  21. throwable.printStackTrace();
  22. System.out.println(throwable.getMessage());
  23. }
  24. });
  25. 执行结果:
  26. 1
  27. 2
  28. 4
  29. 5
  30. 6
  31. java.lang.NullPointerException
  32. at com.loan.rxjavademo.RxjavaTest$3.subscribe(RxjavaTest.java:36)
  33. null
  34. //lamand表达式
  35. Observable.concatArrayDelayError(
  36. Observable.create(emitter -> {
  37. emitter.onNext(1);
  38. emitter.onError(new NullPointerException());
  39. emitter.onNext(2);
  40. emitter.onNext(3);
  41. }),Observable.just(4,5,6))
  42. .subscribe(integer -> System.out.println(integer),throwable -> {
  43. throwable.printStackTrace();
  44. System.out.println(throwable.getMessage());
  45. });
  46. 执行结果:
  47. 1
  48. 4
  49. 5
  50. 6
  51. java.lang.NullPointerException
  52. null

1.4 merge/mergeArray

合并多个(最多四个)Observable的发射物,是按照时间线并行的,如果其中一个Observable发射了onError通知终止,则merge操作符生成的Observable也会立即以onError通知终止。

如果只是两个被观察者合并,则还可以使用mergeWith操作符,Observable.merge(odds,evens)等价于odds.mergeWith(evens)

按时间线并行执行

merge最多连接4个,而mergeArray可以连接多个。

  1. Observable.mergeArray(Observable.intervalRange(1,3,0,1,TimeUnit.SECONDS)
  2. ,Observable.intervalRange(4,3,0,1,TimeUnit.SECONDS))
  3. .subscribe(new Consumer<Long>() {
  4. @Override
  5. public void accept(Long aLong) throws Exception {
  6. System.out.println(aLong);
  7. }
  8. });
  9. //lamand表达式
  10. Observable.mergeArray(Observable.intervalRange(1,3,0,1,TimeUnit.SECONDS)
  11. ,Observable.intervalRange(4,3,0,1,TimeUnit.SECONDS))
  12. .subscribe(integer -> System.out.println(integer));
  13. 执行结果:
  14. 1
  15. 4
  16. 2
  17. 5
  18. 3
  19. 6

1.5 mergeWith

合并两个Observable

  1. Observable.just(1,2,3)
  2. .mergeWith(Observable.just(4,5,6))
  3. .subscribe(new Consumer<Integer>() {
  4. @Override
  5. public void accept(Integer integer) throws Exception {
  6. System.out.println(integer);
  7. }
  8. });
  9. 执行结果:
  10. 1
  11. 2
  12. 3
  13. 4
  14. 5
  15. 6

1.6 zip

通过一个函数将多个Observable的发射物结合到一起,返回一个Observable,使用一个函数按顺序结合两个或多个Observable发射的数据项,然后发射这个函数返回的结果。它按照严格的顺序应用这个函数,只发射与发射数据项最少的那个Observable一样多的数据

事件组合方式 = 严格按照原先事件序列 进行对位合并

最终合并的事件数量 = 多个被观察者(Observable)中数量最少的数量

可以接受1-9个参数

  1. Observable.zip(Observable.just(1, 3, 5), Observable.just(2, 4, 6),
  2. new BiFunction<Integer, Integer, Integer>() {
  3. @Override
  4. public Integer apply(Integer integer, Integer integer2) throws Exception {
  5. return integer+integer2;
  6. }
  7. })
  8. .subscribe(new Consumer<Integer>() {
  9. @Override
  10. public void accept(Integer integer) throws Exception {
  11. System.out.println(integer);
  12. }
  13. });
  14. //Lamand表达式
  15. Observable.zip(Observable.just(1,3,5),Observable.just(2,4,6810),
  16. (integer, integer2) -> integer+integer2)
  17. .subscribe(integer -> System.out.println(integer));
  18. 执行结果:
  19. 3
  20. 7
  21. 11

1.7 combineLatest

combineLatest操作符的行为类似于zip,但是只有当原始的Observable中的每一个都发射了一条数据时zip才发射数据,而combineLatest则是当原始的Observable中任意一个发射了数据时就发射一条数据,当原始Observable的任何一个发射了一条数据时,combineLatest使用一个函数结合他们最近发射的数据,然后发射这个函数的返回值。

  1. Observable.combineLatest(Observable.just(1, 3, 5), Observable.just(2, 4, 6,8,10),
  2. new BiFunction<Integer, Integer, Integer>() {
  3. @Override
  4. public Integer apply(Integer integer, Integer integer2) throws Exception {
  5. System.out.println("integer:"+integer+" integer2:"+integer2);
  6. return integer+integer2;
  7. }
  8. })
  9. .subscribe(new Consumer<Integer>() {
  10. @Override
  11. public void accept(Integer integer) throws Exception {
  12. System.out.println(integer);
  13. }
  14. });
  15. //Lamand表达式
  16. Observable.combineLatest(Observable.just(1,3,5),Observable.just(2,4,6,8,10),
  17. (integer, integer2) -> integer+integer2)
  18. .subscribe(integer -> System.out.println(integer));
  19. 执行结果:
  20. integer:5 integer2:2
  21. 7
  22. integer:5 integer2:4
  23. 9
  24. integer:5 integer2:6
  25. 11
  26. integer:5 integer2:8
  27. 13
  28. integer:5 integer2:10
  29. 15

1.8 join

join操作符结合两个Observable发射的数据,基于时间窗口(针对每条数据特定的原则)选择待集合的数据项。将这些时间窗口实现为一些Observables,他们的生命周期从任何一条Observable发射的每一条数据开始。当这个定义时间窗口的Observable发射了一条数据或者完成时,与这条数据关联的窗口也会关闭。只要这条数据的窗口是打开的,它就继续结合其他Observable发射的任何数据项。

join()四个参数的用途:

  • Observable:源Observable需要组合的Observable,这里可以称之为目标Observable.
  • Function:接收从源Observable发射来的数据,并返回一个Observable,这个Observable的生命周期决定了源Observable发射数据的有效期。
  • FUnction:接受目标Observable发射来的数据,并返回一个Observable,这个Observable的生命周期决定了目标Observable发射数据的有效期。
  • BiFunction:接受从源Observable和目标Observable发射的数据,并将这两个数据祝贺后返回。

join操作符的效果类似于排列组合,把第一个数据源A作为基窗口,它根据自己的节奏不断发射数据元素;第二个数据源B,没发射一个数据,我们都把它和第一个数据源A中已经发射的数据进行一对一匹配。举例来说,如果某一时刻B发射了一个数据”B“,此时A已经发射了a,b,c,d共四个数据,那么合并操作符就是把"B"依次与a,b,c,d配对,得到4组数据:[a,B]、[b,B]、[c,B]、[d,B]。

  1. Observable<Integer> o1=Observable.just(1,2,3);
  2. Observable<Integer> o2=Observable.just(4,5,6);
  3. o1.join(o2, new Function<Integer, ObservableSource<String>>() {
  4. @Override
  5. public ObservableSource<String> apply(Integer integer) throws Exception {
  6. System.out.println("apply1:"+integer);
  7. return Observable.just(integer+"").delay(200,TimeUnit.MILLISECONDS);
  8. }
  9. }, new Function<Integer, ObservableSource<String>>() {
  10. @Override
  11. public ObservableSource<String> apply(Integer integer) throws Exception {
  12. System.out.println("apply2:"+integer);
  13. return Observable.just(integer+"").delay(200,TimeUnit.MILLISECONDS);
  14. }
  15. }, new BiFunction<Integer, Integer, String>() {
  16. @Override
  17. public String apply(Integer integer, Integer integer2) throws Exception {
  18. System.out.println("apply3: integer:"+integer+" intteger2:"+integer2);
  19. return integer+":"+integer2;
  20. }
  21. }).subscribe(new Consumer<String>() {
  22. @Override
  23. public void accept(String s) throws Exception {
  24. System.out.println(s);
  25. }
  26. });
  27. try {
  28. Thread.sleep(10000);
  29. } catch (InterruptedException e) {
  30. e.printStackTrace();
  31. }
  32. 执行结果:
  33. apply1:1
  34. apply1:2
  35. apply1:3
  36. apply2:4
  37. apply3: integer:1 intteger2:4
  38. 1:4
  39. apply3: integer:2 intteger2:4
  40. 2:4
  41. apply3: integer:3 intteger2:4
  42. 3:4
  43. apply2:5
  44. apply3: integer:1 intteger2:5
  45. 1:5
  46. apply3: integer:2 intteger2:5
  47. 2:5
  48. apply3: integer:3 intteger2:5
  49. 3:5
  50. apply2:6
  51. apply3: integer:1 intteger2:6
  52. 1:6
  53. apply3: integer:2 intteger2:6
  54. 2:6
  55. apply3: integer:3 intteger2:6
  56. 3:6

对上述代码做一点修改:

  1. Observable<Integer> o1=Observable.just(1,2,3).delay(200,TimeUnit.MILLISECONDS);
  2. Observable<Integer> o2=Observable.just(4,5,6);
  3. o1.join(o2, new Function<Integer, ObservableSource<String>>() {
  4. @Override
  5. public ObservableSource<String> apply(Integer integer) throws Exception {
  6. System.out.println("apply1:"+integer);
  7. return Observable.just(integer+"").delay(200,TimeUnit.MILLISECONDS);
  8. }
  9. }, new Function<Integer, ObservableSource<String>>() {
  10. @Override
  11. public ObservableSource<String> apply(Integer integer) throws Exception {
  12. System.out.println("apply2:"+integer);
  13. return Observable.just(integer+"").delay(200,TimeUnit.MILLISECONDS);
  14. }
  15. }, new BiFunction<Integer, Integer, String>() {
  16. @Override
  17. public String apply(Integer integer, Integer integer2) throws Exception {
  18. System.out.println("apply3: integer:"+integer+" intteger2:"+integer2);
  19. return integer+":"+integer2;
  20. }
  21. }).subscribe(new Consumer<String>() {
  22. @Override
  23. public void accept(String s) throws Exception {
  24. System.out.println(s);
  25. }
  26. });
  27. try {
  28. Thread.sleep(10000);
  29. } catch (InterruptedException e) {
  30. e.printStackTrace();
  31. }
  32. 执行结果:
  33. apply2:4
  34. apply2:5
  35. apply2:6
  36. apply1:1
  37. apply3: integer:1 intteger2:4
  38. 1:4
  39. apply3: integer:1 intteger2:5
  40. 1:5
  41. apply3: integer:1 intteger2:6
  42. 1:6
  43. apply1:2
  44. apply3: integer:2 intteger2:4
  45. 2:4
  46. apply3: integer:2 intteger2:5
  47. 2:5
  48. apply3: integer:2 intteger2:6
  49. 2:6
  50. apply1:3
  51. apply3: integer:3 intteger2:4
  52. 3:4
  53. apply3: integer:3 intteger2:5
  54. 3:5
  55. apply3: integer:3 intteger2:6
  56. 3:6

1.9 reduce

把被观察者需要发送的事件聚合成1个事件 & 发送

聚合的逻辑根据需求撰写,但本质都是前2个数据聚合,然后与后1个数据继续进行聚合,依次类推

自定义聚合条件,前2个数据聚合得到结果与第三个数据再聚合。以此类推...

示例:累加计算

  1. Observable.just(1,2,3,4,5)
  2. .reduce(new BiFunction<Integer, Integer, Integer>() {
  3. @Override
  4. public Integer apply(Integer integer, Integer integer2) throws Exception {
  5. return integer+integer2;
  6. }
  7. })
  8. .subscribe(new Consumer<Integer>() {
  9. @Override
  10. public void accept(Integer integer) throws Exception {
  11. System.out.println(integer);
  12. }
  13. });
  14. //Lamanda表达式
  15. Observable.just(1,2,3,4,5)
  16. .reduce((integer, integer2) -> integer+integer2)
  17. .subscribe(integer -> System.out.println(integer));
  18. 执行结果:
  19. 15

1.10 collect

将被观察者Observable发送的数据事件收集到一个数据结构里

collect和reduce操作符类似,不过它是需要自己定义收集的容器和收集逻辑

  1. Observable.just(1,2,3,4,5)
  2. .collect(new Callable<List<Integer>>() {
  3. @Override
  4. public List<Integer> call() throws Exception {
  5. return new ArrayList<Integer>();
  6. }
  7. }, new BiConsumer<List<Integer>, Integer>() {
  8. @Override
  9. public void accept(List<Integer> integers, Integer integer) throws Exception {
  10. integers.add(integer);
  11. }
  12. })
  13. .subscribe(new BiConsumer<List<Integer>, Throwable>() {
  14. @Override
  15. public void accept(List<Integer> integers, Throwable throwable) throws Exception {
  16. System.out.println(integers);
  17. }
  18. });
  19. 执行结果:
  20. [1, 2, 3, 4, 5]

2. 连接操作符

connect和refCount是ConnectableObservable所使用的的操作符。

connectableObservable继承自Observable,然而它并不是在调用subscribe()的时候发射数据,而是只有对其使用connect草祖父时它才会发射数据,所以可以用来更灵活地控制数据发射的时机。

2.1 connect

用来触发connectableObservable发射数据的。我们可以等所有的观察者们都订阅了connectableObservable之后再发射数据

2.2 publish

是将普通的Observable转换成connectableObservable


  1. SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
  2. Observable observable=Observable.interval(1,TimeUnit.SECONDS).take(6);
  3. ConnectableObservable<Long> connectableObservable=observable.publish();
  4. connectableObservable.subscribe(new Observer<Long>() {
  5. @Override
  6. public void onSubscribe(Disposable d) {
  7. }
  8. @Override
  9. public void onNext(Long aLong) {
  10. System.out.println("subscriber1:onNext:"+aLong+" time:"+sdf.format(new Date()));
  11. }
  12. @Override
  13. public void onError(Throwable e) {
  14. System.out.println("subscriber1:error:"+e.getMessage());
  15. }
  16. @Override
  17. public void onComplete() {
  18. System.out.println("subscriber1:onComplete");
  19. }
  20. });
  21. connectableObservable.delaySubscription(3, TimeUnit.SECONDS)
  22. .subscribe(new Observer<Long>() {
  23. @Override
  24. public void onSubscribe(Disposable d) {
  25. }
  26. @Override
  27. public void onNext(Long aLong) {
  28. System.out.println("subscriber2:onNext:"+aLong+" time:"+sdf.format(new Date()));
  29. }
  30. @Override
  31. public void onError(Throwable e) {
  32. System.out.println("subscriber2:error:"+e.getMessage());
  33. }
  34. @Override
  35. public void onComplete() {
  36. System.out.println("subscriber2:onComplete");
  37. }
  38. });
  39. connectableObservable.connect();
  40. try {
  41. Thread.sleep(10000);
  42. } catch (InterruptedException e) {
  43. e.printStackTrace();
  44. }
  45. 执行结果:
  46. subscriber1:onNext:2 time:16:25:31
  47. subscriber1:onNext:3 time:16:25:32
  48. subscriber2:onNext:3 time:16:25:32
  49. subscriber1:onNext:4 time:16:25:33
  50. subscriber2:onNext:4 time:16:25:33
  51. subscriber1:onNext:5 time:16:25:34
  52. subscriber2:onNext:5 time:16:25:34
  53. subscriber1:onComplete
  54. subscriber2:onComplete

2.3 replay

生成connectableObservable,保证所有的观察者收到相同的数据序列,即使它们在Observable开始发射数据之后才订阅。

replay操作符返回一个connectableObservable对象,并且可以缓存发射过得数据,这样即使有订阅者在发射之后进行订阅,也能收到之前发射过的数据。不过使用replay操作符最好还是先限定缓存的大小,否则缓存的数据太多时会占用很大一块内存。对缓存的控制可以从空间和时间两个方面来实现。

  1. SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
  2. Observable observable=Observable.interval(1,TimeUnit.SECONDS).take(6);
  3. ConnectableObservable<Long> connectableObservable=observable.replay();
  4. connectableObservable.connect();
  5. connectableObservable.subscribe(new Observer<Long>() {
  6. @Override
  7. public void onSubscribe(Disposable d) {
  8. }
  9. @Override
  10. public void onNext(Long aLong) {
  11. System.out.println("subscriber1:onNext:"+aLong+" time:"+sdf.format(new Date()));
  12. }
  13. @Override
  14. public void onError(Throwable e) {
  15. System.out.println("subscriber1:error:"+e.getMessage());
  16. }
  17. @Override
  18. public void onComplete() {
  19. System.out.println("subscriber1:onComplete");
  20. }
  21. });
  22. connectableObservable.delaySubscription(3, TimeUnit.SECONDS)
  23. .subscribe(new Observer<Long>() {
  24. @Override
  25. public void onSubscribe(Disposable d) {
  26. }
  27. @Override
  28. public void onNext(Long aLong) {
  29. System.out.println("subscriber2:onNext:"+aLong+" time:"+sdf.format(new Date()));
  30. }
  31. @Override
  32. public void onError(Throwable e) {
  33. System.out.println("subscriber2:error:"+e.getMessage());
  34. }
  35. @Override
  36. public void onComplete() {
  37. System.out.println("subscriber2:onComplete");
  38. }
  39. });
  40. try {
  41. Thread.sleep(10000);
  42. } catch (InterruptedException e) {
  43. e.printStackTrace();
  44. }
  45. 执行结果:
  46. subscriber1:onNext:0 time:16:39:16
  47. subscriber1:onNext:1 time:16:39:17
  48. subscriber1:onNext:2 time:16:39:18
  49. subscriber2:onNext:0 time:16:39:18
  50. subscriber2:onNext:1 time:16:39:18
  51. subscriber2:onNext:2 time:16:39:18
  52. subscriber1:onNext:3 time:16:39:19
  53. subscriber2:onNext:3 time:16:39:19
  54. subscriber1:onNext:4 time:16:39:20
  55. subscriber2:onNext:4 time:16:39:20
  56. subscriber1:onNext:5 time:16:39:21
  57. subscriber2:onNext:5 time:16:39:21
  58. subscriber1:onComplete
  59. subscriber2:onComplete

2.4 refCount

将connectableObservable转换成普通的Observable,同时又保持了Hot Observable的特性。当出现第一个订阅者时,refCount会调用connect()。每个订阅者每次都会接收到同样的数据,但是当所有订阅者都取消订阅(dispose)时,refCount会自动dipose上游的Observable。

所有的订阅者都取消订阅后,则数据流停止。如果重新订阅则数据流重新开始。如果不是所有的订阅者都取消了订阅,而是只取消了部分。则部分订阅者/观察者重新开始订阅时,不会从头开始数据流。

  1. SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
  2. Observable observable=Observable.interval(1,TimeUnit.SECONDS).take(6);
  3. ConnectableObservable<Long> connectableObservable=observable.publish();
  4. Observable obsRefCount=connectableObservable.refCount();
  5. observable.subscribe(new Observer<Long>() {
  6. @Override
  7. public void onSubscribe(Disposable d) {
  8. }
  9. @Override
  10. public void onNext(Long aLong) {
  11. System.out.println("subscriber1:onNext:"+aLong+" time:"+sdf.format(new Date()));
  12. }
  13. @Override
  14. public void onError(Throwable e) {
  15. System.out.println("subscriber1:error:"+e.getMessage());
  16. }
  17. @Override
  18. public void onComplete() {
  19. System.out.println("subscriber1:onComplete");
  20. }
  21. });
  22. observable.subscribe(new Observer<Long>() {
  23. @Override
  24. public void onSubscribe(Disposable d) {
  25. }
  26. @Override
  27. public void onNext(Long aLong) {
  28. System.out.println("subscriber2:onNext:"+aLong+" time:"+sdf.format(new Date()));
  29. }
  30. @Override
  31. public void onError(Throwable e) {
  32. System.out.println("subscriber2:error:"+e.getMessage());
  33. }
  34. @Override
  35. public void onComplete() {
  36. System.out.println("subscriber2:onComplete");
  37. }
  38. });
  39. obsRefCount.subscribe(new Observer<Long>() {
  40. @Override
  41. public void onSubscribe(Disposable d) {
  42. }
  43. @Override
  44. public void onNext(Long aLong) {
  45. System.out.println("subscriber3:onNext:"+aLong+" time:"+sdf.format(new Date()));
  46. }
  47. @Override
  48. public void onError(Throwable e) {
  49. System.out.println("subscriber3:error:"+e.getMessage());
  50. }
  51. @Override
  52. public void onComplete() {
  53. System.out.println("subscriber3:onComplete");
  54. }
  55. });
  56. obsRefCount.delaySubscription(3, TimeUnit.SECONDS)
  57. .subscribe(new Observer<Long>() {
  58. @Override
  59. public void onSubscribe(Disposable d) {
  60. }
  61. @Override
  62. public void onNext(Long aLong) {
  63. System.out.println("subscriber4:onNext:"+aLong+" time:"+sdf.format(new Date()));
  64. }
  65. @Override
  66. public void onError(Throwable e) {
  67. System.out.println("subscriber4:error:"+e.getMessage());
  68. }
  69. @Override
  70. public void onComplete() {
  71. System.out.println("subscriber4:onComplete");
  72. }
  73. });
  74. try {
  75. Thread.sleep(10000);
  76. } catch (InterruptedException e) {
  77. e.printStackTrace();
  78. }
  79. 执行结果:
  80. subscriber1:onNext:0 time:16:30:30
  81. subscriber2:onNext:0 time:16:30:30
  82. subscriber3:onNext:0 time:16:30:30
  83. subscriber2:onNext:1 time:16:30:31
  84. subscriber1:onNext:1 time:16:30:31
  85. subscriber3:onNext:1 time:16:30:31
  86. subscriber1:onNext:2 time:16:30:32
  87. subscriber2:onNext:2 time:16:30:32
  88. subscriber3:onNext:2 time:16:30:32
  89. subscriber1:onNext:3 time:16:30:33
  90. subscriber2:onNext:3 time:16:30:33
  91. subscriber3:onNext:3 time:16:30:33
  92. subscriber4:onNext:3 time:16:30:33
  93. subscriber1:onNext:4 time:16:30:34
  94. subscriber2:onNext:4 time:16:30:34
  95. subscriber3:onNext:4 time:16:30:34
  96. subscriber4:onNext:4 time:16:30:34
  97. subscriber2:onNext:5 time:16:30:35
  98. subscriber1:onNext:5 time:16:30:35
  99. subscriber1:onComplete
  100. subscriber2:onComplete
  101. subscriber3:onNext:5 time:16:30:35
  102. subscriber4:onNext:5 time:16:30:35
  103. subscriber3:onComplete
  104. subscriber4:onComplete

RxJava2实战---第七章 合并操作符和连接操作符的更多相关文章

  1. RxJava2实战---第五章 变换操作符和过滤操作符

    RxJava2实战---第五章 变换操作符和过滤操作符 RxJava的变换操作符主要包括以下几种: map():对序列的每一项都用一个函数来变换Observable发射的数据序列. flatMap() ...

  2. RxJava2实战---第六章 条件操作符和布尔操作符

    RxJava2实战---第六章 条件操作符和布尔操作符 RxJava的条件操作符主要包括以下几个: amb():给定多个Observable,只让第一个发射数据的Obsrvable发射全部数据. de ...

  3. Rxjava2实战--第三章 创建操作符

    Rxjava2实战--第三章 创建操作符 Rxjava的创建操作符 操作符 用途 just() 将一个或多个对象转换成发射这个或者这些对象的一个Observable from() 将一个Iterabl ...

  4. Rxjava2实战--第四章 Rxjava的线程操作

    Rxjava2实战--第四章 Rxjava的线程操作 1 调度器(Scheduler)种类 1.1 RxJava线程介绍 默认情况下, 1.2 Scheduler Sheduler 作用 single ...

  5. 2017.2.28 activiti实战--第七章--Spring容器集成应用实例(五)普通表单

    学习资料:<Activiti实战> 第七章  Spring容器集成应用实例(五)普通表单 第六章中介绍了动态表单.外置表单.这里讲解第三种表单:普通表单. 普通表单的特点: 把表单内容写在 ...

  6. 2017.2.21 activiti实战--第七章--Activiti与spring集成(一)配置文件

    学习资料:<Activiti实战> 第七章 Activiti与容器集成 本章讲解activiti-spring可以做的事情,如何与现有系统集成,包含bean的注入.统一事务管理等. 7.1 ...

  7. linq操作符:连接操作符

    linq中的连接操作符主要包括Join()和GroupJoin()两个. 一.Join()操作符 Join()操作符非常类似于T-SQL中的inner join,它将两个数据源进行连接,根据两个数据源 ...

  8. Spring实战第七章————SpringMVC配置的替代方案

    SpringMVC配置的替代方案 自定义DispatherServlet配置 我们之前在SpittrWebAppInitializer所编写的三个方法仅仅是必须要重载的abstract方法.但还有更多 ...

  9. DirectX12 3D 游戏开发与实战第七章内容(上)

    利用Direct3D绘制几何体(续) 学习目标 学会一种无须每帧都要刷新命令队列的渲染流程,以此来优化性能 了解另外两种根签名参数类型:根常量和根描述符 探索如何在程序中生成和绘制常见的几何体:如栅格 ...

随机推荐

  1. Beta冲刺版本第三天

    该作业所属课程:https://edu.cnblogs.com/campus/xnsy/SoftwareEngineeringClass2 作业要求地址:https://edu.cnblogs.com ...

  2. QT容器类

    QList<T> 是一个指针数组,可以使用下标 append(), prepend(), insert() QList<QString> list; list<<& ...

  3. mybatic MapperScannerConfigurer的原理

    原文地址:http://www.cnblogs.com/fangjian0423/p/spring-mybatis-MapperScannerConfigurer-analysis.html 前言 本 ...

  4. SSH框架整合报错org.springframework.web.context.ContextLoaderListener

    是因为在导入的jar包中缺少了一个 org.springframework.web_3.1.4.release.jar 在网上下载即可 下载地址: http://www.java2s.com/Code ...

  5. Pandas中DataFrame数据合并、连接(concat、merge、join)之merge

    二.merge:通过键拼接列 类似于关系型数据库的连接方式,可以根据一个或多个键将不同的DatFrame连接起来. 该函数的典型应用场景是,针对同一个主键存在两张不同字段的表,根据主键整合到一张表里面 ...

  6. 设计一个Mypoint类,求两个点之间的距离

    package Test; public class test6 { public static void main(String[] args) { // TODO Auto-generated m ...

  7. The Cost of JavaScript --------引用

    tl;dr: 想要保持页面的快速运行,你需要仅加载当前页面所需的 JavaScript 代码.优先考虑用户所需,之后运用代码分离懒加载其他内容. Is it happening - 在这个时期,你可以 ...

  8. kubernetes的搭建以及dashboard页面的启动

    ###查看kubernetes状态 ``` kubectl get pods -A #查看相关状态 kubectl get cs #查看k8s的ready状态 kubectl get node #查看 ...

  9. webpack-dev-server 和 html-webpack-plugin的使用

    webpack-dev-server的作用:自动编译 1.webpack-dev-server的使用 1)cnpm i webpack-dev-server -D 2)在package.json中配置 ...

  10. poj 2976 Dropping tests (最大化平均值:二分查找)

    #include<iostream> #include<algorithm> #include<stdio.h> #include<math.h> #d ...