RxJava学习篇之二：操作符的讲解(1)

最新推荐文章于 2023-02-21 14:35:06 发布
最新推荐文章于 2023-02-21 14:35:06 发布
阅读量857 收藏
点赞数
分类专栏： android Java 文章标签： rxjava 操作符 Android Java 响应式编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_34012226/article/details/51315304
版权
android 同时被 2 个专栏收录
42 篇文章 0 订阅
订阅专栏
Java
15 篇文章 0 订阅
订阅专栏

1，just

Just将单个数据转换为发射那个数据的Observable。

例：

 private void testJust(){
        Observable.just(1,2,3,4,5,6)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println(integer);
                    }
                });
    }
输出： 

1
2
3
4
5
6

2.from

Fom将其它种类的对象和数据类型转换为Observable

例：

   private void testFrom(){
        Integer[] nums = new Integer[]{1,2,3,4,5};
        Observable.from(nums)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        System.out.println(integer);
                    }
                });
    }
输出： 

1
2
3
4
5
3,create
Create使用一个函数从头开始创建一个Observable

例：

 private void testCreate(){
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                subscriber.onNext(2);
                subscriber.onNext(3);
                subscriber.onNext(4);
                subscriber.onNext(5);
                subscriber.onCompleted();
            }
        }).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println(integer);
            }
        });
    }
输出： 

1
2
3
4
5
4,empty

Empty创建一个不发射任何数据但是正常终止的Observable

例：

private void testEmpty(){
        Observable.empty()
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        System.out.println("onNext");
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("onErr");
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("onComplete");
                    }
                });
    }
输出： 

onComplete
5，never

Never创建一个不发射数据也不终止的Observable

例：

  private void testNever(){
        Observable.never()
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        System.out.println("onNext");
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("onErr");
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("onComplete");
                    }
                });
    }
输出：

ps:没有输出
6，error
Error创建一个不发射数据以一个错误终止的Observable

例：

 private void testError(){
        Observable.error(new Exception("错误了"))
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        System.out.println("onNext");
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        System.out.println("onErr："+throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        System.out.println("onComplete");
                    }
                });
    }
输出： 
onErr：错误了
7,timer

Timer创建一个Observable，它在一个给定的延迟后发射一个特殊的值。

例：

 private void testTimer() {
        Observable.timer(500, TimeUnit.MILLISECONDS,Schedulers.computation())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Log.e("TAG","onNext:" + aLong);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e("TAG","onErr:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        Log.e("TAG","onComplete" );
                    }
                });
    }
输出： 

10-28 08:55:04.140 3536-3557/tbw.eage.rxjava E/TAG: onNext:0
10-28 08:55:04.140 3536-3557/tbw.eage.rxjava E/TAG: onComplete
ps:特殊值是0L,哈哈~
8，interval
Interval创建一个按固定时间间隔发射整数序列的Observable

例：

  private void testInterval() {
        Observable.interval(2, TimeUnit.SECONDS, Schedulers.computation())
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Log.e("TAG", "onNext:" + aLong);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e("TAG", "onErr:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        Log.e("TAG", "onComplete");
                    }
                });
    }
输出： 
10-28 09:01:12.920 3886-3902/tbw.eage.rxjava E/TAG: onNext:0
10-28 09:01:14.919 3886-3902/tbw.eage.rxjava E/TAG: onNext:1
10-28 09:01:16.918 3886-3902/tbw.eage.rxjava E/TAG: onNext:2
10-28 09:01:18.918 3886-3902/tbw.eage.rxjava E/TAG: onNext:3
10-28 09:01:20.918 3886-3902/tbw.eage.rxjava E/TAG: onNext:4
10-28 09:01:22.919 3886-3902/tbw.eage.rxjava E/TAG: onNext:5
10-28 09:01:24.918 3886-3902/tbw.eage.rxjava E/TAG: onNext:6
ps:每个2秒输出一个自增的数据
9,range

Range创建一个发射特定整数序列的Observable

例：

 private void testRange(){
        Observable.range(5,5)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.e("TAG", "onNext:" + integer);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e("TAG", "onErr:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        Log.e("TAG", "onComplete");
                    }
                });
    }
输出： 
10-28 09:04:38.010 4013-4013/? E/TAG: onNext:5
10-28 09:04:38.010 4013-4013/? E/TAG: onNext:6
10-28 09:04:38.010 4013-4013/? E/TAG: onNext:7
10-28 09:04:38.010 4013-4013/? E/TAG: onNext:8
10-28 09:04:38.010 4013-4013/? E/TAG: onNext:9
10-28 09:04:38.010 4013-4013/? E/TAG: onComplete
ps:是包括开头5的
创建操作符常用的差不多就这些了

1，flatMap

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

Observable

例1：

 private void testFlatMap() {
        Observable.just("Hellon")
                .flatMap(new Func1<String, Observable<String>>() {
                    @Override
                    public Observable<String> call(final String str) {
                        final StringBuffer sb = new StringBuffer(str);
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                sb.append(" Rxjava");
                            }
                        }).start();
                        return Observable.just(sb.toString());
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String str) {
                        Log.e("TAG", "onNext:" + str);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e("TAG", "onErr:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        Log.e("TAG", "onComplete");
                    }
                });
    }
输出： 

10-28 09:18:47.475 4505-4505/tbw.eage.rxjava E/TAG: onNext:Hellon
10-28 09:18:47.475 4505-4505/tbw.eage.rxjava E/TAG: onComplete

ps:注意它的输出，输出的是Hellon,并非Hellon RxJava.因为我在flapMap进行耗时的线程(Thread.sleep()),我们可以

类比实际应用中的网络请求的结果,耗时的结果我们是无法继续向下传递的，如果我们想输出Hellon Rxjava应该如何

做呢？请看例2.

例2：
 
private void testFlatMap() {
        Observable.just("Hellon")
                .flatMap(new Func1<String, Observable<String>>() {
                    @Override
                    public Observable<String> call(final String str) {
                        final PublishSubject<String> subject = PublishSubject.create();
                        final StringBuffer sb = new StringBuffer(str);
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                                sb.append(" Rxjava");
                                subject.onNext(sb.toString());
                                subject.onCompleted();
                            }
                        }).start();
                        return subject;
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String str) {
                        Log.e("TAG", "onNext:" + str);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e("TAG", "onErr:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        Log.e("TAG", "onComplete");
                    }
                });
    }
输出：
 
10-28 09:19:41.393 4648-4665/tbw.eage.rxjava E/TAG: onNext:Hellon Rxjava
10-28 09:19:41.393 4648-4665/tbw.eage.rxjava E/TAG: onComplete
ps:这样我们就输入了Hellon Rxjava,这也是flapMap常用的一个场景。PublishSubject如果使用请看RxJava学习篇之一：基础Observable,Observer,Single,Subject,Scheduler

2,map

Map对Observable发射的每一项数据应用一个函数，执行变换操作

例：

 private void testMap(){
        Observable.just("hellon rxjava")
                .map(new Func1<String, String>() {
                    @Override
                    public String call(String s) {
                        return s.toUpperCase();
                    }
                })
                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String str) {
                        Log.e("TAG", "onNext:" + str);
                    }
                }, new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        Log.e("TAG", "onErr:" + throwable.getMessage());
                    }
                }, new Action0() {
                    @Override
                    public void call() {
                        Log.e("TAG", "onComplete");
                    }
                });
    }
输出： 

10-28 09:30:34.636 4872-4872/tbw.eage.rxjava E/TAG: onNext:HELLON RXJAVA
10-28 09:30:34.636 4872-4872/tbw.eage.rxjava E/TAG: onComplete
3,buffer

Buffer定期收集Observable的数据放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一个值。
例1:

 private void testBuffer() {
        Observable.interval(1, TimeUnit.SECONDS, Schedulers.computation())
                .buffer(3)
                .subscribe(new Action1<List<Long>>() {
                    @Override
                    public void call(List<Long> longs) {
                        for (Long item : longs) {
                            Log.e("TAG", "onNext:" + item);
                        }
                        Log.e("TAG", "onNext------------------------------");
                    }
                });
    }
输出： 
10-28 09:34:03.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:0
10-28 09:34:03.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:1
10-28 09:34:03.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:2
10-28 09:34:03.316 4997-5016/tbw.eage.rxjava E/TAG: onNext------------------------------
10-28 09:34:06.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:3
10-28 09:34:06.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:4
10-28 09:34:06.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:5
10-28 09:34:06.316 4997-5016/tbw.eage.rxjava E/TAG: onNext------------------------------
10-28 09:34:09.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:6
10-28 09:34:09.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:7
10-28 09:34:09.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:8
10-28 09:34:09.316 4997-5016/tbw.eage.rxjava E/TAG: onNext------------------------------
10-28 09:34:12.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:9
10-28 09:34:12.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:10
10-28 09:34:12.316 4997-5016/tbw.eage.rxjava E/TAG: onNext:11
10-28 09:34:12.316 4997-5016/tbw.eage.rxjava E/TAG: onNext------------------------------
ps:每次收集3个值

例2：

 private void testBuffer() {
        Observable.interval(1, TimeUnit.SECONDS, Schedulers.computation())
               .publish(new Func1<Observable<Long>, Observable<List<Long>>>() {
                   @Override
                   public Observable<List<Long>> call(Observable<Long> longObservable) {
                       return longObservable.buffer(Observable.interval(2,TimeUnit.SECONDS));
                   }
               })
                .subscribe(new Action1<List<Long>>() {
                    @Override
                    public void call(List<Long> longs) {
                        for (Long item : longs) {
                            Log.e("TAG", "onNext:" + item);
                        }
                        Log.e("TAG", "onNext------------------------------");
                    }
                });
    }
输出： 
10-28 09:46:39.384 5307-5328/tbw.eage.rxjava E/TAG: onNext:60
10-28 09:46:39.384 5307-5328/tbw.eage.rxjava E/TAG: onNext:61
10-28 09:46:39.384 5307-5328/tbw.eage.rxjava E/TAG: onNext------------------------------
10-28 09:46:41.383 5307-5328/tbw.eage.rxjava E/TAG: onNext:62
10-28 09:46:41.383 5307-5328/tbw.eage.rxjava E/TAG: onNext:63
10-28 09:46:41.383 5307-5328/tbw.eage.rxjava E/TAG: onNext------------------------------
10-28 09:46:43.383 5307-5328/tbw.eage.rxjava E/TAG: onNext:64
10-28 09:46:43.383 5307-5328/tbw.eage.rxjava E/TAG: onNext:65
10-28 09:46:43.383 5307-5328/tbw.eage.rxjava E/TAG: onNext------------------------------
10-28 09:46:45.383 5307-5328/tbw.eage.rxjava E/TAG: onNext:66
10-28 09:46:45.383 5307-5328/tbw.eage.rxjava E/TAG: onNext:67
10-28 09:46:45.383 5307-5328/tbw.eage.rxjava E/TAG: onNext------------------------------
10-28 09:46:47.383 5307-5328/tbw.eage.rxjava E/TAG: onNext:68
10-28 09:46:47.383 5307-5328/tbw.eage.rxjava E/TAG: onNext------------------------------
ps:每隔2秒收集一下数据(publish操作符后面会讲到)
4,groupBy

GroupBy将一个Observable分拆为一些Observables集合，它们中的每一个发射原始Observable的一个子序列

例：

  private void testGroupBy() {
        Observable.just(0, 1, 2, 3, 4, 5)
                .groupBy(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                        return integer*1.0 % 2 == 0;
                    }
                })
                .flatMap(new Func1<GroupedObservable<Boolean, Integer>, Observable<Integer>>() {
                    @Override
                    public Observable<Integer> call(GroupedObservable<Boolean, Integer> groupedObservable) {

                        return groupedObservable.getKey() ? groupedObservable.take(0) : groupedObservable;
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer i) {
                        Log.e("TAG", "onNext:" + i);
                    }
                });
    }
输出： 
10-28 10:12:28.778 5533-5533/tbw.eage.rxjava E/TAG: onNext:1
10-28 10:12:28.778 5533-5533/tbw.eage.rxjava E/TAG: onNext:3
10-28 10:12:28.778 5533-5533/tbw.eage.rxjava E/TAG: onNext:5
5,scan
Scan连续地对数据序列的每一项应用一个函数，然后连续发射结果

例：

private void testScan(){
        Observable.just(1, 2, 3, 4, 5)
                .scan(new Func2<Integer, Integer, Integer>() {
                    @Override
                    public Integer call(Integer sum, Integer item) {
                        return sum + item;
                    }
                }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onNext(Integer item) {
                Log.e("TAG", "onNext:" + item);
            }
            @Override
            public void onError(Throwable error) {
                Log.e("TAG", "onErr:" + error.getMessage());
            }
            @Override
            public void onCompleted() {
                Log.e("TAG","Sequence complete.");
            }
        });
    }
输出： 

10-28 10:15:56.538 6201-6201/tbw.eage.rxjava E/TAG: onNext:1
10-28 10:15:56.539 6201-6201/tbw.eage.rxjava E/TAG: onNext:3
10-28 10:15:56.539 6201-6201/tbw.eage.rxjava E/TAG: onNext:6
10-28 10:15:56.539 6201-6201/tbw.eage.rxjava E/TAG: onNext:10
10-28 10:15:56.539 6201-6201/tbw.eage.rxjava E/TAG: onNext:15
10-28 10:15:56.539 6201-6201/tbw.eage.rxjava E/TAG: Sequence complete.
6，window
Window定期将来自原始Observable的数据分解为一个Observable窗口，发射这些窗口，而不是每次发射一项数据 
 private void testWindow() {
        Observable.just(1, 2, 3, 4, 5)
                .window(2)
                .take(1)
                .flatMap(new Func1<Observable<Integer>, Observable<Integer>>() {
                    @Override
                    public Observable<Integer> call(Observable<Integer> integerObservable) {
                        return integerObservable;
                    }
                })
                .subscribe(new Subscriber<Integer>() {
                    @Override
                    public void onNext(Integer item) {
                        Log.e("TAG", "onNext:" + item);
                    }

                    @Override
                    public void onError(Throwable error) {
                        Log.e("TAG", "onErr:" + error.getMessage());
                    }

                    @Override
                    public void onCompleted() {
                        Log.e("TAG", "Sequence complete.");
                    }
                });
    }
输出： 

10-28 10:25:08.186 6415-6415/tbw.eage.rxjava E/TAG: onNext:1
10-28 10:25:08.186 6415-6415/tbw.eage.rxjava E/TAG: onNext:2
10-28 10:25:08.186 6415-6415/tbw.eage.rxjava E/TAG: Sequence complete.
ps:可能还是看不懂window的用法。window和buffer类似都是缓存数据，不同的是buffer发射来自原始Observable

的数据包，而window发射的是Observables。buffer把缓存的数据封装成一个数据包(List),而window把缓存的数据

封装成一个observable。
变换操作符常用的差不多就这些了

十一月Siy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava2学习教程（五）do 操作符
dolphkon的博客
04-23 501
上一篇学习了map 操作符和 flatmap 操作符，今天我们来一起学习do操作符，那么什么是do操作符呢？ 我们知道当观察者与被观察者之间建立订阅的连接之后，观察者可以接受到被观察者发送的数据，那么do 操作符就是在被观察者执行周期的关键节点听添加了回调，当执行到那个阶段的时候这些回调就会触发。 do 操作符的分类 在RxJava中，do 系列操作符包含了很多个，主要如以下: doOnSu...
RxJava2.x学习教程（二）常用操作符
孙朝阳的博客
05-19 1695
**操作符 ** 操作符官方doc Create Create — create an Observable from scratch by calling observer methods programmatically 最常用的操作符，用于创建一个被观察者（发射事件）...
总结RxJava操作符
小涛的博客
11-10 203
        以下有的操作符会有重载方法，参数不一样，会导致不同结果，若用studio软件的话，用Ctrl+P的快捷键看他有几个参数和类型，根据自己的需求添加相应的参数值。 1. create： 使用该方法创建时，建议在OnSubscribe的call方法中检查订阅状态，以便及时停止发送数据。 Observable.create(new Observable.OnSubsc...
RxJava的使用与深入学习
热门推荐
evan_man的专栏
05-01 1万+
转载请注明出处：http://blog.csdn.net/evan_man 简单介绍     可以将RxJava是一种观察者设计模式的升级版本。使用Rxjava的好处在于，我们可以方便的切换方法的执行线程，对线程动态切换，该过程无需我们自己手动创建和启动线程。使用Rxjava创建的代码虽然出现在同一个线程中，但是我们可以设置使得不同方法在不同线程中执行。上述功能的实现主要归功于RxJava
RxJava系列8：rxjava应用场景
有心好书
02-11 1258
rxjava应用场景 rxjava in retrofit 未使用rxjava时，我们如何使用retrofit 以一个登录请求为例： 在一个interface中声明一个接口请求 /** * 登陆账号 */ @FormUrlEncoded @POST("/maoyan/login") Call&lt;ApiResponse&lt;Login&gt;&gt; login(...
PCI Express学习篇---物理层LTSSM(三) Recovery.Equalization详解
weixin_48180416的博客
05-22 1万+
声明：此文章为原创，转载请注明 转自 Link EQ的过程是首次进入8GT/s及以上的速率时进行的。EQ主要包含四个阶段：Phase0, Phase1, Phase2, Phase3. 在TS1和TS2的格式中包含EC字段，0--Phase0, 1--Phase1, 2--Phase2, 3--Phase3 下面介绍EQ过程的LTSSM状态机的跳转及TS交互 当Link Training到2.5GT/s, L0状态后，硬件自动发起Speed Change到8GT/s（或者从8GT/s速率Spee
响应式流编程
西木空间
12-02 301
Java 9并发编程指南 目录 响应式流编程准备工作实现过程工作原理扩展学习 响应式流（http://www.reactive-streams.org/）提供了具有非阻塞压力的异步流处理机制。 响应式流基于以下三个要素： 信息发布者 多个信息订阅者 发布者与消费者之间的订阅 响应式流规范确定这些类应当如何交互，依据如下规则： 发布者添加希望被通知的订阅者 当订阅者添加到发布者处时接收到通知 ...
Java的RxJava库操作符的用法及实例讲解
09-02
理解RxJava操作符的关键在于理解它们的灵活性和可组合性。Observable可以代表任何异步或同步的数据源，而Subscriber负责处理最终的结果。中间的变换过程是独立的，可以根据需求自由添加或减少操作符，这使得系统具有...
AndroidRxJava实战讲解：优雅实现网络请求轮询
02-25
2.RxJava如此受欢迎的原因，在于其提供了丰富&功能强大的操作符，几乎能完成所有的功能需求3.今天，我将为大家带来Rxjava创建操作符的常见开发应用场景：轮询需求，并结合Retrofit与RxJava实现，希望大家会喜欢。1....
RXJava-Essentials:RXJava Essentials书的学习代码
05-17
3. **Operators（操作符）**: RXJava提供了丰富的操作符，如map、filter、merge、concat、zip等，用于转换、过滤、组合或控制数据流。这些操作符使得数据处理变得简洁且易于理解。 **RXJava-Essentials书中的关键点...
安卓开发进阶之RxJava在实际项目中使用--第一篇
07-01
4. **操作符**：RxJava提供了丰富的操作符，如map、filter、concat、merge、flatMap等，它们可以帮助我们对数据流进行转换、过滤、组合等各种操作，使得数据处理变得更加灵活和高效。 在实际项目中，RxJava的应用...
rxjava从源码完全理解运行原理
抬头看世界
04-03 326
compeletableFuture AltResult 返回结果的简化 AltResult is used to box null as a result, as well as to hold exceptions. NIL null的简化 Minor simplifications rely on (static) NIL (to * box null results) being the only AltResult with a null * exception field, so we don
RXjava中的操作符
最新发布
yuxuehandong的博客
02-21 635
Rxjava中的操作符创建型操作符 interval 创建一个按固定时间间隔发射整数序列的Observable，相当于定时器 上面的代码每隔3s就会调用call方法并打印Log。其中aLong为从0开始的整数每次+1 上面代码也可以合起来写，没有特别说明，本文后面介绍操作符的示例代码都是合起来写的 range 创建发射指定范围的整数序列的Observable，可以拿来替代for循环，发射一个范围内的有序整数序列。第一个参数是起始值，并且不小于0；第二个参数为终值，左闭右开。 打印日志 repeat 创建一个
Android函数响应式编程——必学的RxJava辅助操作符delay、Do、subscribeOn、observeOn、timeout
qq_36523667的博客
12-10 1257
1.delay：让被观察者2秒后再发送数据。 rx.Observable.create(new rx.Observable.OnSubscribe() { @Override public void call(Subscribersuper Long> subscriber) { Long cur = System.currentTimeMillis();
RxJava 学习笔记
xxx_19942的博客
06-13 199
去年这个时候刚刚接触RxJava整理的笔记，先放上来，有空再改改。Rxjava学习笔记 （一）简单入门 1.Rxjava是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库。优点是简洁，并且随着程序逻辑变得越来越复杂，它依然能够保持简洁。 RxJava 的异步实现，是通过一种扩展的观察者模式来实现的。Rxjava基本原理就是观察者(ObServer)通过(Subscribe...
java业务逻辑_RxJava系列番外篇：一个RxJava解决复杂业务逻辑的案例
weixin_32520095的博客
02-21 333
之前写过一系列RxJava1的文章，也承诺过会尽快有RxJava2的介绍。无奈实际项目中还未真正的使用RxJava2，不敢妄动笔墨。所以这次还是给大家分享一个使用RxJava1解决问题的案例，希望对大家在使用RxJava的时候有一点点启发。对RxJava还不了解的同学可以先去看看我之前的RxJava系列文章：业务场景进入App首页后，首先我们需要从数据库中获取当前城市的天气数据，如果数据库中存在天...
RxJava操作符的使用
lggbxf的博客
09-25 257
1.Create： private void create(){ //create 创建Observable //Observable 被观察者 //Subscribers观察者 Observable&lt;String&gt; observable = Observable.create(new Observable.On...
RxJava响应式函数编程
jat的专栏
08-19 393
RxJava响应式函数编程 RxJava最核心的两个东西是Observables（被观察者，事件源）和subscribers（观察者）。observables发出一系列事件，subscribers处理这些事件。 一个Observables可以发出零个或者多个事件，知道结束或者出错。每发出一个事件，就会调用它的subscribee的onNext方法，最后调用subscribe.onNex
干货! RxJava 常见使用场景及小技巧!
风离紫竹zhangqiang的博客
10-20 3374
总结Rxjava最常用的使用场景和小技巧 本文基于RxJava1.x.x ,若用 2.x版本请自行替换部分代码 基础部分:给 Android 开发者的 RxJava 详解 ——扔物线 对RxJava的概念以及基本特性做了详细介绍 本系列相关进阶:   带你入门学习Rxjava ;  RxJava2.x使用以及操作符详解 正文部分: RxJava+RxBi

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值