RxJava2.0第六篇之其他

最新推荐文章于 2023-07-02 13:36:15 发布

mwthe

最新推荐文章于 2023-07-02 13:36:15 发布

阅读量176

点赞数

分类专栏： RXJAVA 2.0

本文链接：https://blog.csdn.net/mwthe/article/details/82824194

版权

RXJAVA 2.0 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

本文要将要介绍的操作符，其中 “(xxx)->{}” 为lambda表达式

一、distinct（去重），filter（条件过滤）

  Observable.just(1, 2, 2, 5, 6, 6, 8, 2, 8, 9)
                .distinct() //去除重复发送的数据
                .filter((integer) -> {   //filter 过滤数据
                    return integer > 5;  //只发送大于5的数据
                })
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(@NonNull Integer integer) throws Exception {
                        Log.e("---->", integer + "===>");
                    }
                });

输出日志：

09-23 18:45:13.318 5588-5588/jy.com.rxjava2 E/---->: 6===>
09-23 18:45:13.318 5588-5588/jy.com.rxjava2 E/---->: 8===>
09-23 18:45:13.318 5588-5588/jy.com.rxjava2 E/---->: 9===>

二、buffer 缓存

2.1 参数只有一个的时候

// count，缓存的数量
public final Observable<List<T>> buffer(int count) {
        return buffer(count, count);
    }

//示例代码

Observable.just(1, 2, 3, 4, 5).buffer(3).subscribe(new Consumer<List<Integer>>() {
            @Override
            public void accept(@NonNull List<Integer> integers) throws Exception {
                Log.e("buffer   : ",   integers  + "\n");
            }
        });

//输出日志：

09-23 21:15:21.468 19242-19242/jy.com.rxjava2 E/buffer   :: [1, 2, 3]
09-23 21:15:21.468 19242-19242/jy.com.rxjava2 E/buffer   :: [4, 5]

2.2 buffer 的重载方法，其中的count表示要缓存的数量，skip(跳过、略过)跳过几个数据，例如下边的例子，发送数据为12345，缓存数量为3个，每次跳过2个数据，所以一次发射的数据为123，那么第二次skip跳过2个，则发射数据为345，第三次跳过2个，则发射5 ; take 方法是标识消费者最多可以接受几个，原本前边可以发射三组数据，现在加入take方法，只能发送两组数据了

public final Observable<List<T>> buffer(int count, int skip) {
        return buffer(count, skip, ArrayListSupplier.<T>asCallable());
    }

 

//示例代码
Observable.just(1, 2, 3, 4, 5)
         .buffer(3, 2)
         .take(2)  // 可以试着去除该方法试试，日志会多处一行日志
         .subscribe(new Consumer<List<Integer>>() {
            @Override
            public void accept(@NonNull List<Integer> integers) throws Exception {
                Log.e("buffer   : ",   integers  + "\n");
            }
        });


//日志输出：

09-23 21:48:13.418 25633-25633/jy.com.rxjava2 E/buffer   :: [1, 2, 3]
09-23 21:48:13.418 25633-25633/jy.com.rxjava2 E/buffer   :: [3, 4, 5]

三、debounce 为除去少于固定发射时间的方法；案例中是去除了少于300毫秒的事件

Observable.create(e -> {
            e.onNext(1);
            Thread.sleep(500);
            e.onNext(2);
            Thread.sleep(100);
            e.onNext(6);
            Thread.sleep(600);
        }).debounce(300, TimeUnit.MILLISECONDS)
                .subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(number -> {
                    Log.e("==debounce====>",number+"");
                });

输入日志：

09-23 22:32:43.568 14078-14078/jy.com.rxjava2 E/==debounce====>: 1
09-23 22:32:43.788 14078-14078/jy.com.rxjava2 E/==debounce====>: 6

四、scan，对发射事件数据扫描观察，该方法中是一个BiFunction接口，前两个输入类型和输出类型自定义，我们示例代码中做了加法运行，当第一次运行的时直接交给了消费者处理，第二次运行才将apply方法参数都初始化进行运行，以后的再将结果继续累加处理

上图可以看出，scan方法是不断从第一个数据累加上来的，注意下面小球的变化

// 元方法
 public final Observable<T> scan(BiFunction<T, T, T> accumulator) {
        ObjectHelper.requireNonNull(accumulator, "accumulator is null");
        return RxJavaPlugins.onAssembly(new ObservableScan<T>(this, accumulator));
    }


//示例代码
 Observable.just(2, 6, 8, 10).scan(new BiFunction<Integer, Integer, Integer>() {
            @Override
            public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
                Log.e("==reduce 1====>",integer + "+" + integer2 + "="+"");
                return integer + integer2;
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer integer) throws Exception {
                Log.e("==reduce 2====>",integer+"");
            }
        });


//日志输出
09-23 22:56:51.588 10428-10428/jy.com.rxjava2 E/==reduce 2====>: 2
09-23 22:56:51.588 10428-10428/jy.com.rxjava2 E/==reduce 1====>: 2+6=
09-23 22:56:51.588 10428-10428/jy.com.rxjava2 E/==reduce 2====>: 8
09-23 22:56:51.598 10428-10428/jy.com.rxjava2 E/==reduce 1====>: 8+8=
09-23 22:56:51.598 10428-10428/jy.com.rxjava2 E/==reduce 2====>: 16
09-23 22:56:51.598 10428-10428/jy.com.rxjava2 E/==reduce 1====>: 16+10=
09-23 22:56:51.598 10428-10428/jy.com.rxjava2 E/==reduce 2====>: 26

五、window方法，收集够三秒后才发射，看着和上面说到的buffer 有点雷同，但是他们的是截然不同的，buffer是用来缓存值的，而window是在规定时间内收集数据的，所以他们都是搞收集工作，但是buffer是缓存数据，为window是在按时间收集数据的

Observable.interval(1, TimeUnit.SECONDS) // 间隔一秒发一次
          .window(3, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Observable<Long>>() {
                    @Override
                    public void accept(@NonNull Observable<Long> longObservable) throws Exception {
                        Log.e(TAG, "Sub Divide begin...\n");
                        longObservable.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<Long>() {
                            @Override
                            public void accept(@NonNull Long aLong) throws Exception {
                                Log.e(TAG, "Next:" + aLong + "\n");
                            }
                        });
                    }
       });


日志：

9-24 15:40:01.798 20151-20151/jy.com.rxjava2 E/ContentValues: Next:0
09-24 15:40:02.448 20151-20151/jy.com.rxjava2 E/ContentValues: Next:1
09-24 15:40:03.418 20151-20151/jy.com.rxjava2 E/ContentValues: Sub Divide begin...
09-24 15:40:03.448 20151-20151/jy.com.rxjava2 E/ContentValues: Next:2
09-24 15:40:04.448 20151-20151/jy.com.rxjava2 E/ContentValues: Next:3
09-24 15:40:05.448 20151-20151/jy.com.rxjava2 E/ContentValues: Next:4
09-24 15:40:06.418 20151-20151/jy.com.rxjava2 E/ContentValues: Sub Divide begin...
09-24 15:40:06.448 20151-20151/jy.com.rxjava2 E/ContentValues: Next:5
09-24 15:40:07.448 20151-20151/jy.com.rxjava2 E/ContentValues: Next:6
09-24 15:40:08.447 20151-20151/jy.com.rxjava2 E/ContentValues: Next:7
09-24 15:40:09.417 20151-20151/jy.com.rxjava2 E/ContentValues: Sub Divide begin...
09-24 15:40:09.447 20151-20151/jy.com.rxjava2 E/ContentValues: Next:8
09-24 15:40:10.447 20151-20151/jy.com.rxjava2 E/ContentValues: Next:9
09-24 15:40:11.447 20151-20151/jy.com.rxjava2 E/ContentValues: Next:10

六、forEach

Observable.just(2,3,6,8,9).forEach(new Consumer<Integer>() {
            @Override
            public void accept(@NonNull Integer integer) throws Exception {
                Log.e("===forEach========>",   + integer + " ");
            }
        });



        Observable.just(2,3,6,8,9).doOnEach(new Consumer<Notification<Integer>>() {
            @Override
            public void accept(@NonNull Notification<Integer> integerNotification) throws Exception {
                Log.e("===doOnEach 1========>",   + integerNotification.getValue() + " ");
            }
        }).subscribe();


输出日志：

09-24 16:49:46.175 23198-23198/jy.com.rxjava2 E/===forEach========>: 2 
09-24 16:49:46.175 23198-23198/jy.com.rxjava2 E/===forEach========>: 3 
09-24 16:49:46.185 23198-23198/jy.com.rxjava2 E/===forEach========>: 6 
09-24 16:49:46.185 23198-23198/jy.com.rxjava2 E/===forEach========>: 8 
09-24 16:49:46.185 23198-23198/jy.com.rxjava2 E/===forEach========>: 9 
09-24 16:49:46.205 23198-23198/jy.com.rxjava2 E/===doOnEach 1========>: 2 
09-24 16:49:46.205 23198-23198/jy.com.rxjava2 E/===doOnEach 1========>: 3 
09-24 16:49:46.205 23198-23198/jy.com.rxjava2 E/===doOnEach 1========>: 6 
09-24 16:49:46.205 23198-23198/jy.com.rxjava2 E/===doOnEach 1========>: 8 
09-24 16:49:46.215 23198-23198/jy.com.rxjava2 E/===doOnEach 1========>: 9 
09-24 16:49:46.215 23198-23198/jy.com.rxjava2 E/===doOnEach 1========>: null

mwthe

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RxJava2.0第六篇之其他

本文要将要介绍的操作符，其中 “(xxx)-&gt;{}” 为lambda表达式一、distinct（去重），filter（条件过滤） Observable.just(1, 2, 2, 5, 6, 6, 8, 2, 8, 9) .distinct() //去除重复发送的数据 .filter((integer) -&gt; ...
复制链接

扫一扫

专栏目录