Rxjava简介(一)

前言

在上一节文章中提到了Lambda与Rxjava结合使用很完美,对AS中如何使用Lambda表达式做了介绍(AS中引入Lambda表达式),接下来介绍下Rxjava的操作符结合Lambda的使用。

---

配置grade对Rxjava的依赖

dependencies {    compile fileTree(dir: 'libs', include: ['*.jar'])    compile 'io.reactivex:rxandroid:1.1.0'    compile 'io.reactivex:rxjava:1.1.0'    //(3)从 maven central 获取最新版本插件    retrolambdaConfig 'net.orfjackal.retrolambda:retrolambda:+'}

配置对retrolambda的依赖请参考我的上一篇文章，这里不再赘述。

配置好了Rxjava下面对其操作符进行介绍.

---

Rxjava本质是观察者模式的普遍应用,微软给的定义是，Rx是一个函数库，让开发者可以利用可观察序列和LINQ风格查询操作符来编写异步和基于事件的程序，使用Rx，开发者可以用Observables表示异步数据流，用LINQ操作符查询异步数据流， 用Schedulers参数化异步数据流的并发处理，Rx可以这样定义：Rx = Observables + LINQ + Schedulers。

ReactiveX.io给的定义是，Rx是一个使用可观察数据流进行异步编程的编程接口，ReactiveX结合了观察者模式、迭代器模式和函数式编程的精华。

使用Rx模式的好处?

Rx模式

使用观察者模式

创建：Rx可以方便的创建事件流和数据流
组合：Rx使用查询式的操作符组合和变换数据流
监听：Rx可以订阅任何可观察的数据流并执行操作
简化代码

函数式风格：对可观察数据流使用无副作用的输入输出函数，避免了程序里错综复杂的状态
简化代码：Rx的操作符通通常可以将复杂的难题简化为很少的几行代码
异步错误处理：传统的try/catch没办法处理异步计算，Rx提供了合适的错误处理机制
轻松使用并发：Rx的Observables和Schedulers让开发者可以摆脱底层的线程同步和各种并发问题.

---

关于观察者模式我前面的博文已经介绍过这里不再介绍.

操作符介绍:

(1)Create

使用一个函数从头开始创建一个Observable,你可以使用Create操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数，编写这个函数让它的行为表现为一个Observable–恰当的调用观察者的onNext，onError和onCompleted方法。

一个形式正确的有限Observable必须尝试调用观察者的onCompleted正好一次或者它的onError正好一次，而且此后不能再调用观察者的任何其它方法。
RxJava将这个操作符实现为 create 方法。

建议你在传递给create方法的函数中检查观察者的isUnsubscribed状态，以便在没有观察者的时候，让你的Observable停止发射数据或者做昂贵的运算。create方法默认不在任何特定的调度器上执行

Observable.create(new Observable.OnSubscribe<String>() {            @Override            public void call(Subscriber<? super String> subscriber) {                subscriber.onNext("hello");                subscriber.onNext("Rxjava");                subscriber.onCompleted();            }        }).subscribe(new Observer<String>() {            @Override            public void onCompleted() {                Log.e("zsl", "onCompleted");            }            @Override            public void onError(Throwable e) {                Log.e("zsl", "onError");            }            @Override            public void onNext(String s) {                Log.e("zsl", s);            }        });

Just

Just将单个数据转换为发射那个数据的Observable。

Just类似于From，但是From会将数组或Iterable的素具取出然后逐个发射，而Just只是简单的原样发射，将数组或Iterable当做单个数据。

注意：如果你传递null给Just，它会返回一个发射null值的Observable。不要误认为它会返回一个空Observable（完全不发射任何数据的Observable），如果需要空Observable你应该使用Empty操作符。

RxJava将这个操作符实现为just函数，它接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable。

另外在创建Subscriber的时候，如果仅仅关心onNext()，这时可以用Action1这个对象

Observable.just("hello2 rxjava","ssss").subscribe(new Action1<String>() {            @Override            public void call(String s) {                Log.e("test3 call",s);            }        });        //等同如下        Observable.just("hello2 rxjava").subscribe((s)->Log.e("test3333 call",s));

From

用from创建observable，这种方式创建，需要传入一个集合，它会一个一个的发射，在subscriber上它会一个一个的接收。

Observable.from(Arrays.asList(strs))                .subscribe(new Action1<String>() {                    @Override                    public void call(String s) {                        Log.e("from",s);                    }});        Observable.from(Arrays.asList(strs)).subscribe((s)->Log.e("from",s));

Map

对Observable发射的每一项数据应用一个函数，执行变换操作,
Map操作符对原始Observable发射的每一项数据应用一个你选择的函数，然后返回一个发射这些结果的Observable。

RxJava将这个操作符实现为map函数。这个操作符默认不在任何特定的调度器上执行。

Observable.from(Arrays.asList(strs)).map(new Func1<String, Integer>() {//第一个参数代表call的参数类型,第二个代表方法返回值            @Override            public Integer call(String s) {                return Integer.valueOf(s)+2;            }        }).subscribe(new Action1<Integer>() {            @Override            public void call(Integer s) {                Log.e("ssss",s.toString());            }        });

flatmap

flatMap操作符接收一个Observable的输出作为输入，同时输出另外一个Observable。在flatMap操作符中，我们可以做一系列的事情，然后输出的新的Observable，这个Observable是我们在Subscriber想要接收的。

Observable.create(new Observable.OnSubscribe<List<String>>() {            @Override            public void call(Subscriber<? super List<String>> subscriber) {                String [] strs={"1","2","3","4","5","6","7"};                subscriber.onNext(Arrays.asList(strs));            }})                .flatMap(new Func1<List<String>, Observable<?>>() {                    @Override                    public Observable<?> call(List<String> list) {                        return Observable.from(list);                    }})                .subscribe(new Action1<Object>() {                    @Override                    public void call(Object o) {                        Log.e("ssss",o.toString());                    }});    }

filter

Filter操作符使用你指定的一个谓词函数测试数据项，只有通过测试的数据才会被发射。

Observable.just(1, 2, 3, 4, 5)          .filter(new Func1<Integer, Boolean>() {              @Override              public Boolean call(Integer item) {                return( item < 4 );              }          }).subscribe(new Subscriber<Integer>() {        @Override        public void onNext(Integer item) {            System.out.println("Next: " + item);        }        @Override        public void onError(Throwable error) {            System.err.println("Error: " + error.getMessage());        }        @Override        public void onCompleted() {            System.out.println("Sequence complete.");        }    });

Next: 1Next: 2Next: 3Sequence complete.

First

只发射第一项（或者满足某个条件的第一项）数据

Observable.just(1, 2, 3)          .first()          .subscribe(new Subscriber<Integer>() {        @Override        public void onNext(Integer item) {            System.out.println("Next: " + item);        }        @Override        public void onError(Throwable error) {            System.err.println("Error: " + error.getMessage());        }        @Override        public void onCompleted() {            System.out.println("Sequence complete.");        }    });

Next: 1Sequence complete.

Take

只发射前面的N项数据.如果你对一个Observable使用take(n)（或它的同义词limit(n)）操作符，而那个Observable发射的数据少于N项，那么take操作生成的Observable不会抛异常或发射onError通知，在完成前它只会发射相同的少量数据。

Observable.just(1, 2, 3, 4, 5, 6, 7, 8)          .take(4)          .subscribe(new Subscriber<Integer>() {        @Override        public void onNext(Integer item) {            System.out.println("Next: " + item);        }        @Override        public void onError(Throwable error) {            System.err.println("Error: " + error.getMessage());        }        @Override        public void onCompleted() {            System.out.println("Sequence complete.");        }    });

Next: 1Next: 2Next: 3Next: 4Sequence complete.

Rxjava中多个操作符配合起来，可以让很复杂的逻辑变得简单，同时，在操作数据的过程中，subcriber并不需要知道中间做了那些操作，只需要知道返回的结果，操作数据也变的简单。

参考：中文文档