版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/fengluoye2012/article/details/79182173
简介
操作符是RxJava中最重要的一部分，主要分为以下几类：创建操作符（Creating ），转换操作符（Transforming），过滤操作符（Filtering），组合操作符（Combining），辅助操作符（Observable Utility），条件操作符（Conditional and Boolean），数学运算操作符（Mathematical and Aggregate），转化操作符（Convert），链接操作符（Connectable）背压操作符（Backpressure）等；可以根据需要实现的效果，依次调用相应的操作符；
Creating操作符的主要方法分别为：
create()：在subscribe（）方法中通过emitter发送事件；
just()：可以发送1个或者多个对象；多个对象通过循环遍历，顺序发送事件
from（）：常用的有fromArray和fromIterable，通过循环遍历，顺序发送事件；
range()：range和rangeLong，从start到start + count通过循环遍历，顺序发送事件；
timer()：发送延时事件
interval()：interval(long initialDelay, long period, TimeUnit unit) 从0到initialDelay，然后每隔period时间，发送一次事件；
我们依次来了解各个方法的用法；
1）create()方法
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Exception {//emitter发射器，
emitter.onNext("Hello World I ");
emitter.onComplete();
//emitter.onError(new Throwable("null"));
emitter.onNext("I");
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
Log.e(tag, "onSubscribe");
//销毁资源，后续的方法不在执行；
//d.dispose();
}
@Override
public void onNext(String s) {
Log.e(tag, s);
}
@Override
public void onError(Throwable t) {
Log.e(tag, "onError");
}
@Override
public void onComplete() {
Log.e(tag, "onComplete");
}
});
运行结果
emitter可以发送多个onNext（）方法，一旦发送onComplete（）或者onError（）方法之后，Disposable将关闭，后续的操作将不再发送；
2）just（）参数最多有10，根据先后顺序依次发送；
Observable.just("hhhh", "hhh").subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, s);
}
});
运行结果
Consumer接收单一值的接口；subscribe(Consumer<? super T> onNext)；从LambdaObserver类中
@Override
public void onNext(T t) {
if (!isDisposed()) {
try {
onNext.accept(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
get().dispose();
onError(e);
}
}
}
可以看出只有onNext.accept(t)才会调用;也就是说只接收发送的onNext事件才会调用accept（）方法；
3）from（）：通过循环遍历，顺序发送事件；
Integer[] arr = {1, 2, 3, 4};
Observable.fromArray(arr).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(tag, String.valueOf(integer));
}
});
List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");
//遍历一遍集合，发送
Observable.fromIterable(list).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.e(tag, s);
}
});
运行结果
4）range（）从start到start + count通过循环遍历，顺序发送事件；
Observable.range(10, 3).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.e(tag, String.valueOf(integer));
}
});
运行结果
5）timer（）发送延时事件，内部默认指定Schedulers.computation()，也可以指定Scheduler ；ComputationScheduler内部维持一个线程池；
Observable.timer(2, TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(tag, "accept timer");
}
});
6）interval()从0到initialDelay，然后每隔period时间，发送一次事件，内部默认指定Schedulers.computation()，也可以指定Scheduler
Observable.interval(1, 5, TimeUnit.SECONDS).subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.e(tag, String.valueOf(aLong));
}
});
运行结果
以上是Creating的常用的主要方法，其内部原理可参考RxJava2.0-Observable原理分析之Create操作符；如有问题，请多指教！