RXJava

关于： https://github.com/lzyzsd/Awesome-RxJava
一、Observables和Subscribers
Observables是被观察者，发出一系列事件，操作事件，（如：网络请求，查询数据库）；Subscribers是观察者，处理结果（如：显示请求后数据，显示查询结果）。

一个Observables可以发出零个或多个事件，指导事件的结束或出错；调用Subscriber的onNext（）或onError()处理事件，调用onError（）时结束

如果Observables没有Subscriber，则它不会发出任何事件。

二、配置

build.gradle
compile ‘io.reactivex:rxjava:1.1.5’
compile ‘io.reactivex:rxandroid:1.1.0’
三、使用

方式一：

1.创建Observable

Observable.create()，泛型为对应观察者接收的类型。call()方法为重写观察者的相应方法（传入参数）。

Observable<String> myObservable=Observable.create(new Observable.OnSubscribe<String>() {
     @Override
     public void call(Subscriber<? super String> subscriber) {
         subscriber.onNext("Hello World");//Subscriber的onNext（）方法会被调用
         subscriber.onCompleted();//Subscriber的onCompleted（）会被调用
     }
});

2.创建Subscriber

方法为对应实现。

Subscriber<String> subscriber=new Subscriber<String>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(String s) {
                System.out.println(s);

        }
    };

Observable.just()会自动向下执行Subscriber的onNext()和onComplete()或onError(),Observable.create()则需要调用Subscriber的方法。

3.观察者和被观察者关联起来

观察者执行onNext()中内容。

myObservable.subscribe(subscriber);  

方式二：

Observable.just()创建Observable，.subscribe()关联观察者，参数是执行的操作。

Observable.just("方式二").subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            System.out.println(s);
        }
    });

关于操作符：

是一种流操作，不是一个操作符执行完后执行下一个，当循环的时候遍历子集，执行一个子集的流操作。例如：flatmap()后，多个doOnNext(),最后subscribe()，执行的是从上到下整体再循环，不是一个操作符循环技术后执行下一个。

1.map（）：对一个Observable的连续操作（响应式编程），将最后的结果给Subscriber处理。

泛型

Observable.just("12").map(new Func1<String, Integer>() {
        @Override
        public Integer call(String s) {
            return Integer.valueOf(s)+1;
        }
    }).map(new Func1<Integer, String>() {
        @Override
        public String call(Integer integer) {
            return String.valueOf(integer)+"-------";
        }
    }).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            System.out.println(s);
        }
    });

2.from（） 参数为集合/数组，省掉遍历的过程。

 String[] item = {"1", "2"};

    Observable.from(item).subscribe(new Action1<String>() {
        @Override
        public void call(String o) {
            System.out.println(o);
        }
    });

3.flatMap()

    Observable.create(new Observable.OnSubscribe<String[]>() {

        @Override
        public void call(Subscriber<? super String[]> subscriber) {
            subscriber.onNext(item);
        }
    }).flatMap(new Func1<String[], Observable<String>>() {
        @Override
        public Observable<String> call(String[] strings) {
            return Observable.from(strings);
        }
    }).subscribe(new Action1<String>() {
         @Override
         public void call(String o) {
             System.out.println(o+"----");
         }
     });

4.take()参数为int类型，表示指定最多几个结果。

5.doOnNext()对传入数据的额外操作，并不会影响数据源的值。（例如在输出前存储等）