三、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