RxJava系列教程之过滤篇（四）

RxJava系列教程：
RxJava系列教程之介绍篇（一）
RxJava系列教程之创建篇（二）
RxJava系列教程之变换篇（三）
RxJava系列教程之过滤篇（四）
RxJava系列教程之线程篇（五）

序言

上章我们讲到了rxjava最神奇的变换，本章我们开始讲rxjava中的和过滤有关的操作符，因为过滤操作符比较简单，那我就教科书式的介绍了。

过滤

filter
没有什么好说的，类似map<T, Boolean>，相当于if了

        Observable.just(1,2,3).filter(new Func1<Integer, Boolean>()
        {
            @Override
            public Boolean call(Integer i)
            {
                return i < 3;
            }
        }).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer i)
            {
                System.out.println(i);
            }
        });

运行结果：

1
2

takeLast
发射最后N个数据

        Observable.just(1,2,3).takeLast(2).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

2
3

last
发射最后一条数据

        Observable.just(1,2,3).last().subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

skip
跳过开始的N条数据

        Observable.just(1, 2, 3).skip(2).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

take
发射开始的N条数据

        Observable.just(1, 2, 3).take(2).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

1
2

first
发射第一条数据

        Observable.just(1, 2, 3).first().subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

takeFirst
发射满足条件的第一个数据

        Observable.just(1, 2, 3).takeFirst(new Func1<Integer, Boolean>()
        {

            @Override
            public Boolean call(Integer arg0)
            {
                return arg0 % 2 == 0;
            }
        }).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

elementAt
发射第N条数据，类似数组的，第一个数据的位置是0

        Observable.just(1, 2, 3).elementAt(2).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

elementAtOrDefault
发射第N条数据，如果超出数据总个数，则发射默认值

        Observable.just(1, 2, 3).elementAtOrDefault(5, 0).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

distinct
去掉重复的数据。这里不支持自己创建的对象，比如你创建N个student类对象，然后再传N个对象进去，就算对象里面的数据相同还是不行的。当然，如果你传N个相同的对象，这是有过滤效果的。

        Observable.just(1, 2, 2, 3).distinct().subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

1
2
3

ofType
发射指定类型的数据

        Observable.just("1", 2, 2, 3).ofType(Integer.class).subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer arg0)
            {
                System.out.println(arg0);
            }
        });

运行结果：

2
2
3

大概就说这么多吧，平时的开发应该已经够了

总结

常见的过滤操作符

 1. filter：类似if
 2. takeLast：发射最后N条数据
 3. last：发射最后一个数据
 4. skip：跳过开始的N条数据
 5. take：只发射开始的N条数据
 6. first：只发射第一条数据
 7. takeFirst：只发射满足条件的第一条数据
 8. elementAt：发射指定位置的数据
 9. elementAtOrDefault：发射指定位置的数据，如果没有，则发射默认值
 10. distinct：去掉重复的数据
 11. ofType：发射指定类型的数据

下集预告：本章我们了解了RxJava的过滤系统，下一章我们将会学习到rxjava中的线程调度方面的东西，可以让某些操作在指定的线程中运行，那我们就可以愉快的把耗时操作丢给子线程操作了，敬请期待吧！

RxJava系列教程之过滤篇（四）

序言

过滤

总结

猜你喜欢