RxJava----使用

基本使用

        //一个最简单的实现        //一个Observable（被观察者）        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {            @Override            public void call(Subscriber<? super String> subscriber) {                subscriber.onNext("Hello RxJava");                subscriber.onCompleted();            }        });        //一个Subscriber（订阅者）        Subscriber<String> subscriber = new Subscriber<String>() {            public void onCompleted() {                log("Complete!");            }            @Override            public void onError(Throwable e) {                log(e.getMessage().toString());            }            @Override            public void onNext(String s) {                log(s);            }        };        //订阅，Observable执行subscribe之后，调用call方法        observable.subscribe(subscriber);

        // Outputs:        // Hello RxJava        // Complete!

操作符

ReactiveX - Operators

创建操作符

Operator RxJava—-操作符：创建Observable just 将一个或多个对象转换成发射这个或这些对象的一个Observable from 将一个Iterable, 一个Future, 或者一个数组转换成一个Observable defer 在观察者订阅之前不创建这个Observable，为每一个观察者创建一个新的Observable range 创建发射指定范围的整数序列的Observable interval 创建一个定时发射整数序列的Observable timer 创建在一个指定的延迟之后发射单个数据的Observable empty 创建一个什么都不做直接通知完成的Observable never 创建一个不发射任何数据的Observable error 创建一个什么都不做直接通知错误的Observable create 通过调用观察者的方法从头创建一个Observable

过滤操作符

这些操作符用于从Observable发射的数据中进行选择

Operator RxJava—-操作符：过滤Observable filter 过滤数据 elementAt 发射第N项数据 sample 定期发射Observable最近的数据 debounce 只有在空闲了一段时间后才发射数据，通俗的说，就是如果一段时间没有操作，就执行一次操作 ignoreElements 忽略所有的数据，只保留终止通知(onError或onCompleted) take 只发射开始的N项数据 skip 跳过开始的N项数据 take和skip的重载 take(250, TimeUnit.MILLISECONDS)，只发射前250毫秒的数据 takeLast 只发射最后的N项数据和 skipLast 跳过最后的N项数据 takeWhile 发射原始Observable的数据，直到一个特定的条件为真，然后跳过剩余的数据 skipWhile 丢弃原始Observable发射的数据，直到一个特定的条件为假，然后发射原始Observable剩余的数据 takeUntil 和 发射来自原始Observable的数据，直到第二个Observable发射了一个数据或一个通知 skipUntil 丢弃原始Observable发射的数据，直到第二个Observable发射了一个数据，然后发射原始Observable的剩余数据 first and last 首项（和末项），只发射满足条件的第一条（或者最后一条）数据 distinct 去重，过滤掉重复数据项 distinctkeySelector distinctUntilChanged 过滤掉连续重复的数据 distinctUntilChangedkeySelector

条件和布尔操作符

Operator RxJava—-操作符：检查Observable all 判断Observable发射的所有的数据项是否都满足某个条件 ofType 只发射指定类型的数据 single 强制返回单个数据，否则抛出异常 exists isEmpty contains 判断Observable是否会发射一个指定的数据项 defaultIfEmpty sequenceEqual

算术和聚合操作符

Operator RxJava—-操作符：聚合Observable count 来统计源 Observable 完成的时候一共发射了多少个数据 reudce 按顺序对数据序列的每一个应用某个函数，然后返回这个值 collect toList toSortedList toMap toMultimap concat 不交错的连接多个Observable的数据 concatWith amb 给定多个Observable，只让第一个发射数据的Observable发射全部数据 ambWith

转换操作符

Operator RxJava—-操作符：转换Observable map 对序列的每一项都应用一个函数来变换Observable发射的数据序列 cast materialize 将Observable转换成一个通知列表convert an Observable into a list of Notifications dematerialize 将上面的结果逆转回一个Observable flatMap 将Observable发射的数据集合变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable concatMap switchMap 将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据 flatMapIterable buffer 它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个 window 定期将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项 scan 对Observable发射的每一项数据应用一个函数，然后按顺序依次发射每一个值 groupBy 分组，将原来的Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据

组合操作符

Operator RxJava—-操作符：组合Observable repeat 创建一个重复发射指定数据或数据序列的Observable repeatWhen 创建一个重复发射指定数据或数据序列的Observable，它依赖于另一个Observable发射的数据 startWith 在发射原来的Observable的数据序列之前，先发射一个指定的数据序列或数据项 merge 将多个Observable合并为一个 mergeWith mergeDelayError 合并多个Observables，让没有错误的Observable都完成后再发射错误通知 switchOnNext 将一个发射Observables的Observable转换成另一个Observable，后者发射这些Observables最近发射的数据 switchMap 将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射的数据 zip 使用一个函数组合多个Observable发射的数据集合，然后再发射这个结果 zipWith combineLatest 当两个Observables中的任何一个发射了一个数据时，通过一个指定的函数组合每个Observable发射的最新数据（一共两个数据），然后发射这个函数的结果 join 无论何时，如果一个Observable发射了一个数据项，只要在另一个Observable发射的数据项定义的时间窗口内，就将两个Observable发射的数据合并发射 groupJoin

辅助操作符

Operator RxJava—-操作符：辅助Observable materialize( ) 将Observable转换成一个通知列表convert an Observable into a list of Notifications dematerialize( ) 将上面的结果逆转回一个Observable timestamp( ) 给Observable发射的每个数据项添加一个时间戳 serialize( ) 强制Observable按次序发射数据并且要求功能是完好的 cache( ) 记住Observable发射的数据序列并发射相同的数据序列给后续的订阅者 observeOn( ) 指定观察者观察Observable的调度器 subscribeOn( ) 指定Observable执行任务的调度器 doOnEach( ) 注册一个动作，对Observable发射的每个数据项使用 doOnCompleted( ) 注册一个动作，对正常完成的Observable使用 doOnError( ) 注册一个动作，对发生错误的Observable使用 doOnTerminate( ) 注册一个动作，对完成的Observable使用，无论是否发生错误 doOnSubscribe( ) 注册一个动作，在观察者订阅时使用 doOnUnsubscribe( ) 注册一个动作，在观察者取消订阅时使用 finallyDo( ) 注册一个动作，在Observable完成时使用 delay( ) 延时发射Observable的结果 delaySubscription( ) 延时处理订阅请求 timeout 如果在一个指定的时间段后还没发射数据，就发射一个异常 timestamp 给Observable发射的每个数据项添加一个时间戳 timeInterval 定期发射数据 using( ) 创建一个只在Observable生命周期存在的资源 single( ) 强制返回单个数据，否则抛出异常 singleOrDefault( ) 如果Observable完成时返回了单个数据，就返回它，否则返回默认数据 toFuture( ), toIterable( ), toList( ) 将Observable转换为其它对象或数据结构

生命周期

subscribe

Observable.subscribe 有好几个重载函数，每个函数都是某种情况的简化形式。

Subscription    subscribe()Subscription    subscribe(Action1<? super T> onNext)Subscription    subscribe(Action1<? super T> onNext, Action1<java.lang.Throwable> onError)Subscription    subscribe(Action1<? super T> onNext, Action1<java.lang.Throwable> onError,Action0 onComplete)Subscription    subscribe(Observer<? super T> observer)Subscription    subscribe(Subscriber<? super T> subscriber)

• 第一个 subscribe() 函数只是订阅事件，但是不去处理这些事件。
• 带有一个或者多个 Action 参数的，使用这些参数来构造一个 Subscriber 对象。
• 这些参数分别对应 onNext、onError和 onComplete这三种类型的事件，如果没有提供则代表不处理这个类型的事件。
  下面的示例演示处理 error 的情况：

        Subject<Integer, Integer> s = ReplaySubject.create();        s.subscribe(new Action1<Integer>() {            @Override            public void call(Integer integer) {                log(integer + "");            }        }, new Action1<Throwable>() {            @Override            public void call(Throwable throwable) {                log(throwable.getMessage().toString());            }        });        s.onNext(0);        s.onError(new Exception("Oops"));

结果：

0Oops

如果你不处理 error，则 在发生错误的时候，会抛出 OnErrorNotImplementedException 异常。该异常发生在生产者这边，上面的示例 生产者和消费者位于同一线程，所以你可以直接 try- catch 住，但是在实际应用中，生产者和消费者通常不再同一个线程，所以最好还是提供一个 错误处理函数，否则你不知道错误发生了并导致事件流结束了。

unsubscribe

在事件流结束发射之前，你可以主动停止接收事件。
每个 subscribe（） 都会返回一个 Subscription 示例，该示例有两个函数：

boolean isUnsubscribed()void unsubscribe()

只需要调用 unsubscribe 函数就可以停止接收数据了。

        Subject<Integer, Integer>  values = ReplaySubject.create();        Subscription subscription = values.subscribe(new Action1<Integer>() {            @Override            public void call(Integer integer) {                log(integer + "");            }        }, new Action1<Throwable>() {            @Override            public void call(Throwable throwable) {                log(throwable.getMessage().toString());            }        }, new Action0() {            @Override            public void call() {                log("Done");            }        });        values.onNext(0);        values.onNext(1);        subscription.unsubscribe();        values.onNext(2);

结果：

01

一个 observer 调用 unsubscribe 取消监听并不妨碍同一个 observable 上的其他 Observer 对象。
同时，RxJava的另外一个好处就是它处理unsubscribing的时候，会停止整个调用链。如果你使用了一串很复杂的操作符，调用unsubscribe将会在他当前执行的地方终止。不需要做任何额外的工作！

        Subject<Integer, Integer>  values = ReplaySubject.create();        Subscription subscription1 = values.subscribe(new Subscriber<Integer>() {            @Override            public void onCompleted() {                log("Complete!" );            }            @Override            public void onError(Throwable e) {                log("First: "+e.getMessage().toString() );            }            @Override            public void onNext(Integer integer) {                log("First: "+integer);            }        });        Subscription subscription2 = values.subscribe(new Subscriber<Integer>() {            @Override            public void onCompleted() {                log("Complete!" );            }            @Override            public void onError(Throwable e) {                log("Second: "+e.getMessage().toString() );            }            @Override            public void onNext(Integer integer) {                log("Second: "+integer);            }        });        values.onNext(0);        values.onNext(1);        subscription1.unsubscribe();        log("Unsubscribed first" );        values.onNext(2);

结果：

First: 0Second: 0First: 1Second: 1Unsubscribed firstSecond: 2

onError 和 onCompleted

onError 和 onCompleted 意味着结束事件流。
observable 需要遵守该规范，在 onError 或者 onCompleted 发生后就不应该再发射事件了。

        Subject<Integer, Integer>  values = ReplaySubject.create();        Subscription subscription1 = values.subscribe(new Subscriber<Integer>() {            @Override            public void onCompleted() {                log("Complete!" );            }            @Override            public void onError(Throwable e) {                log("First: "+e.getMessage().toString() );            }            @Override            public void onNext(Integer integer) {                log("First: "+integer);            }        });        values.onNext(0);        values.onNext(1);        values.onCompleted();        values.onNext(2);

结果：

First: 0First: 1Complete！

释放资源

Subscription 和其使用的资源绑定在一起。
所以你应该记得释放 Subscription 来释放资源。
使用 Subscriptions 的工厂函数可以把 Subscription 和需要的资源绑定在一起，然后可以使用 unsubscribe 来释放绑定的资源。

Subscription s= Subscriptions.create(new Action0() {            @Override            public void call() {                log("Clean" );            }        });  s.unsubscribe();

结果：

Clean

项目源码 GitHub求赞，谢谢！
引用：
RxJava 教程第一部分：入门之 生命周期管理 - 云在千峰