androidRxJava操作符（三）

过滤操作符

1 filter

filter操作符是对源Observable产生的结果自定义规则进行过滤，只有满足条件的结果才会提交给订阅者

 private void filterOb()
    {
        Observable.just(1, 2, 3, 4).filter(new Func1<Integer, Boolean>()
        {
            @Override
            public Boolean call(Integer integer)
            {
                return integer > 2;//将大于二的数值提交给订阅者
            }
        }).subscribe(new Action1<Integer>()
        {
            @Override
            public void call(Integer integer)
            {
                Log.e(TAG, "filter:" + integer);//输出拼接结果
            }
        });
    }

2 elementAt

elementAt操作符用来返回指定位置的数据。和它类似的有elementAtOrDefault(int,T),其可以允许默认值。具体代码如下

 private void elementAtOb()
    {
        Observable.just(1, 2, 3, 4).elementAt(2)//下标从0开始
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "elementAt:" + integer);//输出拼接结果
                    }
                });
    }

elementAtOrDefault

  private void elementAtOb()
    {
        Observable.just(1, 2, 2, 4)
//                .elementAt(2)//下标从0开始
                .elementAtOrDefault(0,3)//返回指定位置的值，如果超出下标则返回默认值不抛出异常
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "elementAt:" + integer);//输出拼接结果
                    }
                });
    }

3 distinct

distinct操作符用来去重，其只允许还没发射过的数据项通过。和她雷瑟的还有distinctUntilChanged操作符，它用来去除连续重复的数据。

 private void distinctOb()
    {
        Observable.just(1, 2, 2, 3, 3, 3, 4, 5, 5)
                .distinct()
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "distinct:" + integer);//输出拼接结果
                    }
                });
    }

  private void distinctOb()
    {
        Observable.just(3, 3, 3)
                .distinctUntilChanged()
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "distinct:" + integer);//输出拼接结果
                    }
                });
    }

4 skit、take

skip将Observable发射的数据过滤掉前n项，而take操作符只取前n项，另外还有SkipLast和takeLast操作符，则是从后面进行过滤操作

private void skitOb()
    {
        Observable.just(1, 2, 3, 4, 5, 6)
                .skip(2)//从第3位去
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "skit:" + integer);//输出拼接结果
                    }
                });
    }

 private void skitOb()
    {
        Observable.just(1, 2, 3, 4, 5, 6)
//                .skip(2)//从第3位去
                .take(2)//取前两位
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "skit:" + integer);//输出拼接结果
                    }
                });
    }

  private void skitOb()
    {
        Observable.just(1, 2, 3, 4, 5, 6)
//                .skip(2)//从第3位去
//                .take(2)//取前两位
                .skipLast(2)//取倒数第二位前的数据
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "skit:" + integer);//输出拼接结果
                    }
                });
    }

 

  private void skitOb()
    {
        Observable.just(1, 2, 3, 4, 5, 6)
//                .skip(2)//从第3位去
//                .take(2)//取前两位
//                .skipLast(2)//取倒数第二位前的数据
                .takeLast(2)//取后两位
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "skit:" + integer);//输出拼接结果
                    }
                });
    }

 5 ignoreElements

ignoreElements操作符忽略所有源Observable产生的结果，只把Observable的onCompleted和onError事件通知给订阅者

private void ignoreElements()
    {
        Observable.just(1, 2, 3, 4, 5)
                .ignoreElements()//忽略所有的操作结果只要C和ONe
                .subscribe(new Observer<Integer>()
                {
                    @Override
                    public void onCompleted()
                    {
                        Log.e(TAG, "onCompleted");
                    }

                    @Override
                    public void onError(Throwable e)
                    {
                        Log.e(TAG, "onError");
                    }

                    @Override
                    public void onNext(Integer integer)
                    {
                        Log.e(TAG, "onNext"+integer);
                    }
                });
    }

6 throttleFirst

throttleFirst操作符则会定期发射这个时间段里源Observable发射的第一个数据，throttleFirst操作符默认在computation调度器上执行，和throttleFirst操作符类似的有sample操作符，它会定时地发射源Observable最近的数据，其他的都会被过滤掉。

private void throttleFirst()
    {
        Observable.create(new Observable.OnSubscribe<Integer>()
        {//创建一个被观察者
            @Override
            public void call(Subscriber<? super Integer> subscriber)
            {
                for (int i = 0; i < 10; i++)
                {
                    subscriber.onNext(i);//继续发送下一个
                    try
                    {
                        Thread.sleep(100);//睡100ms，如果补睡眠则只有第一个数据会被发射
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
                subscriber.onCompleted();//完成
            }
        }).throttleFirst(200, TimeUnit.MICROSECONDS)//每200ms
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "throttleFirst" + integer);
                    }
                });
    }

 

7 throttleWithTimeOut

通过事件来限流，Observable每次发射出来一个数据后就会进行计时。如果在设定好的事件结束前源Observable有新的数据发射出来，这个数据就会被丢弃，同时throttleWithTimeOut重新开始计时。如果每次都是在计时结束前发射数据，那么这个限流就会走向极端：只会发射最后一个数据。其默认在computation调度器上执行。和throttleWithTimeOut操作符类似的有deounce操作符，它不仅可以使用时间来进行过滤，还可以根据一个函数来进行限流。

 private void throttleWithTimeOut()
    {
        Observable.create(new Observable.OnSubscribe<Integer>()
        {
            @Override
            public void call(Subscriber<? super Integer> subscriber)
            {
                for (int i = 0; i < 10; i++)
                {
                    subscriber.onNext(i);
                    int sleep = 100;
                    if (i % 3 == 0)
                    {
                        sleep = 300;
                    }
                    try
                    {
                        Thread.sleep(sleep);
                    } catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
        }).throttleWithTimeout(200, TimeUnit.MILLISECONDS)
                .subscribe(new Action1<Integer>()
                {
                    @Override
                    public void call(Integer integer)
                    {
                        Log.e(TAG, "throttleWithTimeOut" + integer);
                    }
                });
    }