参考资料 https://mcxiaoke.gitbooks.io/rxdocs/content/
RxJava 使用也有一段时间了，到现在可以说是比较流行这个框架。之前一直都没有做一个整理，需要用到时一下子没有想起来又要各种查资料文档，怪麻烦的。于是决定好好梳理一下。RxJava使用关键就是对操作符的熟练了。这里讲述下RxJava的创建操作符的简单介绍跟用法。
1.create
看使用例子：
/** * create */ Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(ObservableEmitter<Integer> e) throws Exception { e.onNext(1); } }).subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { Logs("create", "onSubscribe"); } @Override public void onNext(Integer integer) { Logs("create", "接受到的数字是： " + integer); } @Override public void onError(Throwable e) { Logs("create", "onError"); } @Override public void onComplete() { Logs("create", "onComplete"); } }); /** * 输出结果 * 2019-03-15 09:47:18.097 3945-3945/com.example.testlink D/create: onSubscribe * 2019-03-15 09:47:18.102 3945-3945/com.example.testlink D/create: 接受到的数字是： 1 */
通过create操作符发送了一个integer类型的数据1事件，最终在订阅者接收到这个数据。create是最简单的操作了，没什么难度。
2.defer
延迟订阅，defer操作符会以被订阅后数据的最终结果作为事件发出，接收到的数据同样也是最新的。使用场景：在事件被订阅前可能会被重复修改，但每次需要用到最新的数据源。
/** * 延迟 defer */ i = 100; Observable<Integer> defer = Observable.defer(new Callable<ObservableSource<Integer>>() { @Override public ObservableSource<Integer> call() throws Exception { return Observable.just(i); } }); i = 1000; Observer<Integer> observer1 = new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { Logs("defer1", "onSubscribe"); } @Override public void onNext(Integer integer) { Logs("defer1", "onNext---->" + integer); } @Override public void onError(Throwable e) { Logs("defer1", "onError"); } @Override public void onComplete() { Logs("defer1", "onComplete"); } }; defer.subscribe(observer1); /** * 可以看到i是1000，而不是原来的100，i的值已经被更新掉了 * 输出结果： * 2019-03-14 15:59:22.310 4015-4015/com.example.testlink D/defer1: onSubscribe * 2019-03-14 15:59:22.311 4015-4015/com.example.testlink D/defer1: onNext---->1000 * 2019-03-14 15:59:22.311 4015-4015/com.example.testlink D/defer1: onComplete * */
3.fromArray
fromxxxxxx操作符的都是由RxJava1.x的from拆分来的。fromArray功能上参考数组的遍历。
Integer[] is = {1, 2, 3, 4, 5, 6}; Observable.fromArray(is).subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(Integer integer) { Logs("fromArray", "integer----> " + integer); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); /** * 运行结果 * 2019-03-15 09:47:18.138 3945-3945/com.example.testlink D/fromArray: integer----> 1 * 2019-03-15 09:47:18.139 3945-3945/com.example.testlink D/fromArray: integer----> 2 * 2019-03-15 09:47:18.139 3945-3945/com.example.testlink D/fromArray: integer----> 3 * 2019-03-15 09:47:18.140 3945-3945/com.example.testlink D/fromArray: integer----> 4 * 2019-03-15 09:47:18.140 3945-3945/com.example.testlink D/fromArray: integer----> 5 * 2019-03-15 09:47:18.140 3945-3945/com.example.testlink D/fromArray: integer----> 6 */
4.fromIterable
这个操作符就不给出例子了，就是集合的遍历，大家都懂的。最后接收的数据就是集合内的每一个子元素。
5.fromCallback
fromeCallback接收一个Callback对象，但是实际发出的却可以是任意数据。接收的数据与发出的数据保持同步，但是使用在Callback返回前可以对这个数据进行修改。
Observable.fromCallable(new Callable<Integer>() { @Override public Integer call() throws Exception { int k = 111; k++; return k; } }).subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(Integer integer) { Logs("fromCallable", "接受的数字是---> " + integer); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); /** * 输出结果 * 2019-03-15 10:36:40.637 4439-4439/com.example.testlink D/fromCallable: 接受的数字是---> 112 * */
6.fromFuture
fromFuture接收一个 Future类型的对象，有4个重载方法，可以设置回调延迟时间，调度器等。可以对回调的数据进行修改等。
Observable.fromFuture(new Future<Integer>() { @Override public boolean cancel(boolean mayInterruptIfRunning) { Logs("fromFuture", "" + mayInterruptIfRunning); return false; } @Override public boolean isCancelled() { return false; } @Override public boolean isDone() { return false; } @Override public Integer get() throws ExecutionException, InterruptedException { return 2; } @Override public Integer get(long timeout, TimeUnit unit) throws ExecutionException, InterruptedException, TimeoutException { return 1; } }).subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(Integer integer) { Logs("fromFuture", "接收的数据----> " + integer); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); /** * 2019-03-15 11:46:23.995 6175-6175/com.example.testlink D/fromFuture: 接收的数据----> 2 */
当然还也有其他使用方法：将一个ObservableSource通过toFuture()转换成future来使用。
Observable.fromFuture(Observable.just(1).toFuture(), 2000, TimeUnit.MILLISECONDS) .subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(Integer integer) { Logs("fromFuture","接收的数据----> "+integer); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } });
7.interval
定时发送无限个连续事件，从0开始，有4个重载方法，可以设置延迟时间，调度器等。
Observable.interval(3000, TimeUnit.MILLISECONDS).subscribe(new Observer<Long>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(Long aLong) { Logs("interval", "aLong ----> " + aLong); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); /** * 从输出时间上可以看到每隔3秒就发送一次事件,后续还有，只不过强行停止了，因为他是发送无限个事件的。 * 2019-03-15 14:08:10.469 7488-7506/com.example.testlink D/interval: aLong ----> 0 * 2019-03-15 14:08:13.467 7488-7506/com.example.testlink D/interval: aLong ----> 1 * 2019-03-15 14:08:16.468 7488-7506/com.example.testlink D/interval: aLong ----> 2 * 2019-03-15 14:08:19.468 7488-7506/com.example.testlink D/interval: aLong ----> 3 * 2019-03-15 14:08:22.467 7488-7506/com.example.testlink D/interval: aLong ----> 4 * 2019-03-15 14:08:25.468 7488-7506/com.example.testlink D/interval: aLong ----> 5 * 2019-03-15 14:08:28.468 7488-7506/com.example.testlink D/interval: aLong ----> 6 * ....... */
8. intervalRange
从源码方法可以知晓，intervalRange 跟 interval作用一样，不过参数多了几个，可以指定开始的位置，发射数量。
@CheckReturnValue @SchedulerSupport(SchedulerSupport.COMPUTATION) public static Observable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit) { return intervalRange(start, count, initialDelay, period, unit, Schedulers.computation()); }
9.just
依次发送多个数据事件，可发送的事件数量最多为10个。当发送的数据多于1个时，just 内部时调用自己 fromArray 来完成的。
同样的，当 fromArray 的数量只有一个时，调用的是 just 来实现。
Observable.just("s","s","s","s").subscribe(new Observer<String>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(String s) { Logs("just","接收的数据---> "+s); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); /** * 2019-03-15 14:25:16.729 7800-7800/com.example.testlink D/just: 接收的数据---> s * 2019-03-15 14:25:16.729 7800-7800/com.example.testlink D/just: 接收的数据---> s * 2019-03-15 14:25:16.730 7800-7800/com.example.testlink D/just: 接收的数据---> s * 2019-03-15 14:25:16.730 7800-7800/com.example.testlink D/just: 接收的数据---> s */
10.range、 rangeLong
指定从某个位置开始发射数据，并指定发送的数量。
range 跟 rangeLong 其实是一样的，只是接收的数据类型不一样，range 接收的是 integer，rangeLong 接收的 long类型。
@CheckReturnValue @SchedulerSupport(SchedulerSupport.NONE) public static Observable<Integer> range(final int start, final int count) {.......
11.timer
延迟指定的时间后发射一个事件给订阅着。跟 interval 一样都可以延迟时间后发射事件，但是 timer 只会发射一个事件，而interval 如果没有限制的话，是连续无限个事件。
outTime();//打印一下时间分割线 Observable.timer(3000, TimeUnit.MILLISECONDS).subscribe(new Observer<Long>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(Long aLong) { Logs("timer","接收的数据----> "+aLong); } @Override public void onError(Throwable e) { } @Override public void onComplete() { } }); /** * 输出结果： 3秒后发射了一个事件 * 2019-03-15 14:48:17.556 8255-8255/com.example.testlink D/timer: --------时间分割线---------------------- * 2019-03-15 14:48:20.569 8255-8274/com.example.testlink D/timer: 接收的数据----> 0 */
Rxjava2.x 的创建型操作符就介绍这么多了，如果对各位看官有所帮助不妨点个赞！若有偏差欢迎指出纠正，蟹蟹~ _QAQ_~
