RxJava操作符(3)-过滤

Debounce

Debonuce操作符可以通过时间进行过滤，也可以通过函数进行过滤。通过时间进行过滤时，Observable每次发射一个数据出去时，都会进行记时，如果在规定的时间内，Observable发射出一个新的数据，那么老的数据将会被丢弃，如果发射的时机一直都是这样，那么最后只能成功发射出去最后一个数据。通过函数进行过滤时，会生成一个新的
Observable，如果此时原Observable发射一个新数据，而此时上一次的Observable还没操作完成，则上一次的Observable将会被丢弃。

原理图如下：

Debounce操作符使用如下：

通过时间进行过滤：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                for (int i = 0; i < 5; i++) {
                    if (i % 2 == 0) {
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    if (!subscriber.isUnsubscribed()) {
                        subscriber.onNext(i);
                    }
                }
                subscriber.onCompleted();
            }
        }).subscribeOn(Schedulers.computation())
                .debounce(1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread());
    }

通过函数进行过滤：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5, 6).debounce(new Func1<Integer, Observable<Integer>>() {
            @Override
            public Observable<Integer> call(final Integer integer) {
                return Observable.create(new Observable.OnSubscribe<Integer>() {
                    @Override
                    public void call(Subscriber<? super Integer> subscriber) {
                        if (integer % 2 == 0 && !subscriber.isUnsubscribed()) {
                            subscriber.onNext(integer);
                            subscriber.onCompleted();
                        }
                    }
                });
            }
        });
    }

运行代码，结果如下：

     

Distinct

Distinct操作符进行数据出重的操作。

原理图如下：

Distinct操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 2, 3, 2, 2, 3, 4, 5, 6).distinct();
    }

运行代码，结果如下：

DistinctUtilChanged

DistinctUtilChanged操作符对连续的数据进行出重的操作。

原理图如下：

DistinctUntilChanged操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 2, 3, 2, 2, 3, 4, 5, 6)
                .distinctUntilChanged();
    }

运行代码，结果如下：

ElementAt

ElementAt操作符获取原始Observable发射的数据序列指定索引位置的数据项，然后当做自己的唯一数据发射。

原理图如下：

ElementAt操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4).elementAt(3);
    }

运行代码，结果如下：

ElementAtOrDefault

ElementAtOrDefault操作符当索引位置不超过Observable发射的数据序列的大小时，功能跟ElementAt操作符一样，当超过时会以一个默认值返回。如果索引位置为负数，将会抛出数组越界的异常。

原理图如下：

ElementAtOrDefault操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5)
                .elementAtOrDefault(6, 6);
    }

运行代码，结果如下：

Filter

Filter操作符是传入一个函数，当发射出去的数据满足该函数的条件时，才被Filter操作符发射出去，如果不满足数据将会被过滤。

原理图如下：

Filter操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5).filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                if (integer % 2 == 0) {
                    return true;
                }
                return false;
            }
        });
    }

运行代码，结果如下：

OfType

OfType操作符传入class，只返回属于该class类型的数据。

原理图如下：

OfType操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2.0, 3d).ofType(Integer.class);
    }

运行代码，结果如下：

First

First操作符是返回第一条满足条件的数据。

原理图如下：

First操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2.0, 3d).first();
    }

运行代码，结果如下：

Last

Last操作符是返回最后一条满足条件的数据。

原理图如下：

Last操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3).last();
    }

运行代码，结果如下：

Skip

Skip操作符是过滤调前m项数据。假设要发射数据的列表是n，而skip传入的参数是m，则Skip操作符只会发射[n-m, n]这个区间的数据。TakeLast操作符只取后面的m项数据，如果传入的数据是TakeLast(n-m)，则跟Skip(m)发射出去的数据是一样的。

原理图如下：

Skip操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5, 6).skip(3);
    }

运行代码，结果如下：

Take

Take操作符是只取前m项数据。假设要发射数据的列表是n，而take传入的参数是m，则Take操作符只会发射[1, m]这个区间的数据。SkipLast操作符只取前面的m项数据，如果传入的数据是SkipLast(n-m)，则跟Take(m)发射出去的数据是一样的。

原理图如下：

Take操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.just(1, 2, 3, 4, 5, 6).take(3);
    }

运行代码，结果如下：

Sample

Sample操作符在每个采样周期内，它总是发射原始Observable的最近发射的数据。

原理图如下：

Sample操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.interval(1, TimeUnit.SECONDS)
                .sample(5, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread());
    }

运行代码，结果如下：

ThrottleFirst

ThrottleFirst操作符在每个采样周期内，它总是发射原始Observable的第一个数据。

原理图如下：

ThrottleFirst操作符使用如下：

    @Override
    protected void createObservable() {
        super.createObservable();
        mObservable = Observable.interval(1, TimeUnit.SECONDS)
                .throttleFirst(5, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread());
    }

运行代码，结果如下：

接下来就是鸣谢了，非常感谢以下两位博主，相关链接如下：

https://mcxiaoke.gitbooks.io/rxdocs/content/operators/Filtering-Observables.html

http://mushuichuan.com/2015/12/11/rxjava-operator-3/

github地址