初识RxJava(五)过滤类 操作符

  1. 云栖社区>
  2. 博客>
  3. 正文

初识RxJava(五)过滤类 操作符

吾乃韩小呆 2018-11-09 22:53:39 浏览575
展开阅读全文

前言:

前面已经记录了四种操作符,分别是 创建、延时、转换、组合 操作符,每天闲来无事看一篇。找个时间 写个demo 敲一下,然后就大体记住了,会用的第一步是记住 ,记住的第一步 是认识。下面开始 过滤 操作符的 笔记记录;

正文:

1、filter 操作符

1)、作用

从被观察者内过滤掉不符合需求条件的 内容,将符合条件的内容 发射给 观察者;

2)、代码
 /**
     * filter 操作符
     */
    private void filterMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7).filter(new Predicate<Integer>() {
            @Override
            public boolean test(Integer integer) throws Exception {
                return integer > 4;
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                logDUtils("onNext:" + integer);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("onComplete");
            }
        });
    }
3)、效果

效果

2、ofType 操作符

1)、作用

用于过滤被观察者 发送的数据 得到指定类型数据,将筛选后的数据 在 观察者那里进行接收;

2)、代码
 /**
     * ofType 操作符
     */
    private void ofTypeMethod() {
        Observable.just(1, "Android", "Java", 4, "航展")
                .ofType(String.class).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("onSubscribe");
            }

            @Override
            public void onNext(String s) {
                logDUtils("onNext:" + s);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("onComplete");
            }
        });
    }
3)、效果

效果

3、skip 操作符 和 skipLast 操作符

1)、作用

skip: 跳过发射事件 的前 n 个 数据;
skipLast :跳过发射事件 的后 n 个 数据。

2)、代码
  /**
     * skip 操作符 和 skipLast 操作符
     */
    @SuppressLint("CheckResult")
    private void skipMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7, 8).skip(2).skipLast(3)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        logDUtils("accept:" +integer);
                    }
                });
    }
3)、效果

效果

4、distinct 操作符 和 distinctUntilChanged 操作符

1)、作用

distinct : 过滤重复的事件

distinctUntilChanged : 过滤连续重复事件

2)、代码
  /**
     * distinct 操作符 和  distinctUntilChanged 操作符
     */

    @SuppressLint("CheckResult")
    private void distinctMethod() {
        Observable.just(1, 22, 33, 44, 55, 33, 1, 22).distinct().subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                logDUtils("distinct--->accept:" + integer);
            }
        });

        Observable.just(1, 1, 2, 3, 4, 4, 5, 6, 6,5).distinctUntilChanged().subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                logDUtils("distinctUntilChanged--->accept:" + integer);
            }
        });
    }
3)、效果

效果

5、take 操作符 和 takeLast 操作符

1)、作用

take :只获取 被观察者 发送的数据的 前几位数据
takeLast :只获取 被观察 发送的数据 的后几位数据

2)、代码
  /**
     * take 操作符 和 takeLast 操作符
     */
    @SuppressLint("CheckResult")
    private void takeMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7).take(3).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("take--->onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                logDUtils("take--->onNext:" + integer);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("take--->onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("take--->onComplete");
            }
        });


        Observable.just(1, 2, 3, 4, 5, 6, 78, 9).takeLast(4).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                logDUtils("takeLast--->onSubscribe");
            }

            @Override
            public void onNext(Integer integer) {
                logDUtils("takeLast--->onNext:" + integer);
            }

            @Override
            public void onError(Throwable e) {
                logDUtils("takeLast--->onError:" + e.getMessage());
            }

            @Override
            public void onComplete() {
                logDUtils("takeLast--->onComplete");
            }
        });
    }
3)、效果

效果

6、throttleFirst 操作符 和 throttleLast 操作符

1)、作用

throttleFirst :规定事件内 只发送 这段时间内的 第 1 次数据
throttleLast :规定事件内 只发送 这段时间内的 最后 1 次数据

2)、代码

    /**
     * throttleFirst 操作符 和 throttleLast 操作符
     */
    @SuppressLint("CheckResult")
    private void throttleFirstAndThrottleLastMethod() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                emitter.onNext("a");
                Thread.sleep(400);
                emitter.onNext("b");
                Thread.sleep(400);
                emitter.onNext("c");
                Thread.sleep(400);
                emitter.onNext("d");
                Thread.sleep(400);
                emitter.onNext("e");
                Thread.sleep(400);
                emitter.onNext("f");
            }
        }).throttleFirst(2, TimeUnit.SECONDS).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                logDUtils("throttleFirst--->accept:" + s);
            }
        });

        // interval 操作符: 从 0 开始 每隔 100 毫秒 产生一个递增的 long 类型数据
        Observable.interval(100, TimeUnit.MILLISECONDS)
                .throttleLast(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        logDUtils("throttleLast---->accept:" + aLong);
                    }
                });
    }
3)、效果

效果

7、Sample 操作符

作用

在某段时间内,只发送该段时间内最新即最后一次 1次事件 类似于 throttleLast 操作符

8、throttleWithTimeout 操作符 和 debounce 操作符

1)、作用

只发射给 观察者的 规定时间内 最后一个数据。

2)、代码
  /**
     * debounce 操作符 和 throttleWithTimeout 操作符
     */
    @SuppressLint("CheckResult")
    private void debounceAndThrottleWithTimeoutMethod() {
        //intervalRange : 开始数字为 1 数字数量为90 初始延迟1毫秒 数字间隔为100毫秒
        Observable.intervalRange(1,90,1,100, TimeUnit.MILLISECONDS)
                .debounce(101, TimeUnit.MILLISECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        logDUtils("accept:" + aLong);
                    }
                });
    }
3)、效果

效果

8、elementAt 操作符

1)、作用

获取指定索引处的 数据

2)、代码
  /**
     * elementAt  操作符
     */
    @SuppressLint("CheckResult")
    private void elementAtMethod() {
        Observable.just(1, 2, 3, 4, 5, 6, 7).elementAt(4).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                logDUtils("accept:" + integer);
            }
        });
    }
3)、效果

效果

注意: 初始索引为 0

9、firstElement 操作符 和 lastElement 操作符

1)、作用

firstElement :获取首个 数据
lastElement :获取最后一个数据

2)、代码
  /**
     * firstElement 操作符 和 lastElement 操作符
     */
    @SuppressLint("CheckResult")
    private void firstElementAndLastElementMethod() {
        Observable.just("首个", "a", "b", "c").firstElement().subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                logDUtils("accept:" + s);
            }
        });
    }
3)、效果

效果

10、elementAtOrError操作符

作用

与 elementAt 操作符配合使用,当出现越界的情况 抛出异常。

网友评论

登录后评论
0/500
评论
吾乃韩小呆
+ 关注