三、RxJava基础 ---过滤操作（Filtering Observables）

一、前言

上篇主要介绍了 转化操作，本篇介绍过滤操作

二、过滤操作 （Filtering Observables）

Operators that selectively emit items from a source Observable.

从Observable 的源头，有选择的发送。

1、filter

过滤数据。内部通过OnSubscribeFilter过滤数据。

    /**
     * filter 过滤数据。内部通过OnSubscribeFilter过滤数据。
     */
    private void filterTest(){
        Observable.just(1,2,3,4)
                .filter(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {
                           if(integer>2){
                               return true; //  返回 ture 不拦截
                           } else {
                               return false; // 返回 false 拦截
                           }
                        //return integer >2; // 过滤数字大于2 的
                    }
                }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                Log.d("filter-->","onCompleted");
            }

            @Override
            public void onError(Throwable throwable) {
                Log.d("filter-->","onError:"+throwable.toString());
            }

            @Override
            public void onNext(Integer integer) {
                Log.d("filter-->","onNext"+integer.toString());
            }
        });

    }

2、distinct

过滤重复数据，内部通过OperatorDistinct实现。

/**
     * distinct :过滤重复数据，
     */
    private void distinctTest(){
        //基本数据类型
        Observable.just(1,2,3,2,3,4,2,1,2)
                .distinct()
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("---","debounce"+integer);// debounce1 debounce2 debounce3 debounce4
                    }
                });
        //引用数据类型
        Student yasuo = new Student("亚索",12,1022L);
        Student gailun = new Student("盖伦",18,1001L);
        Student timo = new Student("提莫",6,1009L);

        Observable.just(yasuo,yasuo,gailun,timo).distinct().subscribe(new Action1<Student>() {
            @Override
            public void call(Student student) {
                Log.d("student:","---->"+student.toString());
            }
        });
    }

3、ElementAt

发射某一项数据. 如果 超出Obserable 的长度， 则会报：
Caused by: java.lang.IndexOutOfBoundsException: 3 is out of bounds
使用 elementAtOrDefault 更安全点。

  /**
     * elementAt :过滤重复数据，
     */
    private void elementAtTest(){
        Observable.just(1,2,3,2,3,4,2,1,2)
                .elementAt(1)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("call","-"+integer);// 2 
                    }
                });
        Observable.just(1,2,3)
                .elementAtOrDefault(3,0)//超出 Observable 长度 ,默认值 0  更安全点 
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("call","-"+integer); // 0
                    }
                });
    }

4、first / last

如果您只对Observable 的第一项感兴趣，或者符合某些标准条件项目的第一个，您可以通过第一个操作符过滤可观察到的项。

   /**
     * first :只对Observable 的第一项感兴趣，或者符合某些标准条件项目的第一个，
     */
    private void firstOrLastTest(){
        Observable.just(1,2,3)
                .first()// 第一个Observable 
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("first","---->"+integer); // 1
                    }
                });
        Observable.just(1,1,3,2,2,3)
                .first(new Func1<Integer, Boolean>() {
                    @Override
                    public Boolean call(Integer integer) {

                        return integer>2;// 符合 条件 第一个Observable 
                    }
                })
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("first","---->"+integer);// 3
                    }
                });
// lsat 用法 通过first
//        Observable.just(1,2,3)
//                .last() 
//                .subscribe(new Action1<Integer>() {
//                    @Override
//                    public void call(Integer integer) {
//                        Log.d("---","debounce -"+integer);// debounce -3
//                    }
//                });
    }

5、IgnoreElements

丢弃所有数据，只发射错误或正常终止的通知。内部通过OperatorIgnoreElements实现。

6、sample/throttleLast

定期发射Observable最近的数据。内部通过OperatorSampleWithTime实现。

  private void sampleTest() {
        Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                subscriber.onNext(1);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext(2);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext(3);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                subscriber.onNext(4);
                subscriber.onNext(5);
                subscriber.onNext(6);
            }
        }).sample(999, TimeUnit.MILLISECONDS)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("sample", "-" + integer.toString());// 2 3 6 
                    }
                });
    }

7、skip

跳过开始的N项数据或者一定时间内的数据。内部通过OperatorSkip和OperatorSkipTimed实现过滤。

   /**
     * skip : 跳过开始的N项数据或者一定时间内的数据。
     */
    private void skipTest(){
        Observable.just(1,2,3,4)
                .skip(2)//跳过 几个
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("skip","-->"+integer);// 3  4
                    }
                });
    }

8、take

只发射开始的N项数据或者一定时间内的数据。内部通过OperatorTake和OperatorTakeTimed过滤数据。

 Observable.just(3,4,5,6)
            .take(3)//发射前三个数据项
            .take(100, TimeUnit.MILLISECONDS)//发射100ms内的数据

9、takeLast

只发射最后的N项数据或者一定时间内的数据。内部通过OperatorTakeLast和OperatorTakeLastTimed过滤数据。takeLastBuffer和takeLast类似，不同点在于takeLastBuffer会收集成List后发射。

 Observable.just(3,4,5,6)
            .takeLast(3)
            .subscribe(integer -> Log.d("JG",integer.toString()));//4,5,6