总览
1. 创建型操作符：
即创建被观察者对象，并发送事件。
1.1 create（）
最基本的创建被观察者的方法（上一篇代码示例中有用）。
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
observableEmitter.onNext("emit A");
observableEmitter.onNext("emit B");
observableEmitter.onNext("emit C");
observableEmitter.onComplete();
}
});
1.2 just（）
将传入的数据一次发射出去（最多10个）
public class Test {
private static void test(){
Observable<String> observable = Observable.just("1","2","3","4","5","6","7","8","9","10");
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(s);
}
};
observable.subscribe(consumer);
}
public static void main(String[] args) {
test();
}
}运行结果：
之所以是最多10个，看他的源码就能发现：因为他的构造函数最多支持10个参数
@SchedulerSupport("none")
public static <T> Observable<T> just(T item) {
ObjectHelper.requireNonNull(item, "The item is null");
return RxJavaPlugins.onAssembly(new ObservableJust(item));
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
return fromArray(item1, item2);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
return fromArray(item1, item2, item3);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3, T item4) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
return fromArray(item1, item2, item3, item4);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
ObjectHelper.requireNonNull(item5, "The fifth item is null");
return fromArray(item1, item2, item3, item4, item5);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
ObjectHelper.requireNonNull(item5, "The fifth item is null");
ObjectHelper.requireNonNull(item6, "The sixth item is null");
return fromArray(item1, item2, item3, item4, item5, item6);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
ObjectHelper.requireNonNull(item5, "The fifth item is null");
ObjectHelper.requireNonNull(item6, "The sixth item is null");
ObjectHelper.requireNonNull(item7, "The seventh item is null");
return fromArray(item1, item2, item3, item4, item5, item6, item7);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
ObjectHelper.requireNonNull(item5, "The fifth item is null");
ObjectHelper.requireNonNull(item6, "The sixth item is null");
ObjectHelper.requireNonNull(item7, "The seventh item is null");
ObjectHelper.requireNonNull(item8, "The eighth item is null");
return fromArray(item1, item2, item3, item4, item5, item6, item7, item8);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
ObjectHelper.requireNonNull(item5, "The fifth item is null");
ObjectHelper.requireNonNull(item6, "The sixth item is null");
ObjectHelper.requireNonNull(item7, "The seventh item is null");
ObjectHelper.requireNonNull(item8, "The eighth item is null");
ObjectHelper.requireNonNull(item9, "The ninth item is null");
return fromArray(item1, item2, item3, item4, item5, item6, item7, item8, item9);
}
@SchedulerSupport("none")
public static <T> Observable<T> just(T item1, T item2, T item3, T item4, T item5, T item6, T item7, T item8, T item9, T item10) {
ObjectHelper.requireNonNull(item1, "The first item is null");
ObjectHelper.requireNonNull(item2, "The second item is null");
ObjectHelper.requireNonNull(item3, "The third item is null");
ObjectHelper.requireNonNull(item4, "The fourth item is null");
ObjectHelper.requireNonNull(item5, "The fifth item is null");
ObjectHelper.requireNonNull(item6, "The sixth item is null");
ObjectHelper.requireNonNull(item7, "The seventh item is null");
ObjectHelper.requireNonNull(item8, "The eighth item is null");
ObjectHelper.requireNonNull(item9, "The ninth item is null");
ObjectHelper.requireNonNull(item10, "The tenth item is null");
return fromArray(item1, item2, item3, item4, item5, item6, item7, item8, item9, item10);
}看他的代码，其实内部调用了 fromArray（）操作符（下面马上说到），可以理解为简化版的fromArray（），但是呢又不一样！！！
1.3 fromIterable（）：
将传入的一组数据按角标一次发射出去，即发射一组数据。
private static void test(){
List<String> yys = new ArrayList<>();
yys.add("一");
yys.add("二");
yys.add("三");
yys.add("四");
yys.add("五");
Observable<String> observable = Observable.fromIterable(yys);
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println(s);
}
};
observable.subscribe(consumer);
}运行结果：
1.4 fromArray（）：
对一组数据进行观察，即把一组数据一次性发射被观察者（因此，观察者的onNext（）只执行一次）
private static void test(){
List<String> yys = new ArrayList<>();
yys.add("一");
yys.add("二");
yys.add("三");
yys.add("四");
yys.add("五");
Observable<List<String>> observable = Observable.fromArray(yys);
Consumer<List<String>> consumer = new Consumer<List<String>>() {
@Override
public void accept(List<String> s) throws Exception {
System.out.println(s);
}
};
observable.subscribe(consumer);
}运行结果：
1.5 timer（）：
延迟指定时长发射一个类型为long、数值为0的事件（默认在新线程发射）。他有两个重载方法：
@SchedulerSupport("io.reactivex:computation")
public static Observable<Long> timer(long delay, TimeUnit unit) {
return timer(delay, unit, Schedulers.computation());
}
@SchedulerSupport("custom")
public static Observable<Long> timer(long delay, TimeUnit unit, Scheduler scheduler) {
ObjectHelper.requireNonNull(unit, "unit is null");
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
return RxJavaPlugins.onAssembly(new ObservableTimer(Math.max(delay, 0L), unit, scheduler));
}示例代码：
Observable.
timer(5, TimeUnit.SECONDS).
subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable disposable) {
System.out.println("onSubscribe");
}
@Override
public void onNext(Long aLong) {
System.out.println("onNext aLong:" + aLong);
}
@Override
public void onError(Throwable throwable) {
System.out.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
});运行结果：
感觉并没有按指定时长延时，另外发射的0也没收到。。。
1.6 interval（）：
按照指定的时间间隔，每次发送一个事件，发送事件的序列为：默认从0开始，无限递增的整数序列（默认在新线程中进行）
1.7 intervalRange（）：
作用和interval一样，但这里可以指定发送数据的个数，而interval是无限发射，除非主动停止。
1.8 range（）:
发射指定范围的序列：可指定发射范围，作用同 intervalRange 一样，不同的是，range是无延迟发射。
2. 转换型操作符：
变换被观察者发送的事件，将事件按照一定的规则变换，然后将变换后的事件发送出去。
2.1 map（）：
将被观察者转换成新的被观察者发射出去，观察者收到的是新的被观察者发射出的事件。
示例代码：将int类型的值转化为string并发射，则观察者收到的就是string类型的值。
Observable
.just(2)
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "将Integer类型的： " + integer + "转化为string";
}
})
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable disposable) {
System.out.println("onSubscribe");
}
@Override
public void onNext(String s) {
System.out.println("onNext");
System.out.println(s);
}
@Override
public void onError(Throwable throwable) {
System.out.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
});运行结果：
2.2 flatMap（）：
使用一个指定的函数对原始Observable发射的每一项数据执行变换操作，这个函数返回一个本身也发射数据的Observable，然后FlatMap合并这些Observables发射的数据，最后将合并后的结果当做它自己的数据序列发射。
flatmap通过一个函数将原来的数据的每一项进行转换，并将返回的数据进行Observable包装，然后将所有这些Observable转换成一个Observable发射，所执行的结果可能和元数据items中数据的顺序不能保证
示例代码：
Integer[] items = {1, 2, 3, 4, 5, 6};
Observable.fromArray(items).flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
return Observable.just("flatMap----" + integer);
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable disposable) {
System.out.println("onSubscribe");
}
@Override
public void onNext(String o) {
// System.out.println("onNext");
System.out.println(o);
}
@Override
public void onError(Throwable throwable) {
System.out.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
});运行结果：
2.3 concatMap（）：
基本与 flatMap（）类似，只是他可以保证观察者收到的和被观察者发射时的顺序。
2.4 buffer（）：
将要发射的数据按照一定的间隔分成若干段，然后把分成的每一段作为一个新的被观察者发射出去，即简单理解为分组发射。他有多个重载方法：
@SchedulerSupport("none")
public final Observable<List<T>> buffer(int count) {
return this.buffer(count, count);
}
@SchedulerSupport("none")
public final Observable<List<T>> buffer(int count, int skip) {
return this.buffer(count, skip, ArrayListSupplier.asCallable());
}
@SchedulerSupport("none")
public final <U extends Collection<? super T>> Observable<U> buffer(int count, int skip, Callable<U> bufferSupplier) {
ObjectHelper.verifyPositive(count, "count");
ObjectHelper.verifyPositive(skip, "skip");
ObjectHelper.requireNonNull(bufferSupplier, "bufferSupplier is null");
return RxJavaPlugins.onAssembly(new ObservableBuffer(this, count, skip, bufferSupplier));
}
@SchedulerSupport("none")
public final <U extends Collection<? super T>> Observable<U> buffer(int count, Callable<U> bufferSupplier) {
return this.buffer(count, count, bufferSupplier);
}
@SchedulerSupport("io.reactivex:computation")
public final Observable<List<T>> buffer(long timespan, long timeskip, TimeUnit unit) {
return this.buffer(timespan, timeskip, unit, Schedulers.computation(), ArrayListSupplier.asCallable());
}
@SchedulerSupport("custom")
public final Observable<List<T>> buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler) {
return this.buffer(timespan, timeskip, unit, scheduler, ArrayListSupplier.asCallable());
}
@SchedulerSupport("custom")
public final <U extends Collection<? super T>> Observable<U> buffer(long timespan, long timeskip, TimeUnit unit, Scheduler scheduler, Callable<U> bufferSupplier) {
ObjectHelper.requireNonNull(unit, "unit is null");
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.requireNonNull(bufferSupplier, "bufferSupplier is null");
return RxJavaPlugins.onAssembly(new ObservableBufferTimed(this, timespan, timeskip, unit, scheduler, bufferSupplier, 2147483647, false));
}
@SchedulerSupport("io.reactivex:computation")
public final Observable<List<T>> buffer(long timespan, TimeUnit unit) {
return this.buffer(timespan, unit, Schedulers.computation(), 2147483647);
}
@SchedulerSupport("io.reactivex:computation")
public final Observable<List<T>> buffer(long timespan, TimeUnit unit, int count) {
return this.buffer(timespan, unit, Schedulers.computation(), count);
}
@SchedulerSupport("custom")
public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count) {
return this.buffer(timespan, unit, scheduler, count, ArrayListSupplier.asCallable(), false);
}
@SchedulerSupport("custom")
public final <U extends Collection<? super T>> Observable<U> buffer(long timespan, TimeUnit unit, Scheduler scheduler, int count, Callable<U> bufferSupplier, boolean restartTimerOnMaxSize) {
ObjectHelper.requireNonNull(unit, "unit is null");
ObjectHelper.requireNonNull(scheduler, "scheduler is null");
ObjectHelper.requireNonNull(bufferSupplier, "bufferSupplier is null");
ObjectHelper.verifyPositive(count, "count");
return RxJavaPlugins.onAssembly(new ObservableBufferTimed(this, timespan, timespan, unit, scheduler, bufferSupplier, count, restartTimerOnMaxSize));
}
@SchedulerSupport("custom")
public final Observable<List<T>> buffer(long timespan, TimeUnit unit, Scheduler scheduler) {
return this.buffer(timespan, unit, scheduler, 2147483647, ArrayListSupplier.asCallable(), false);
}
@SchedulerSupport("none")
public final <TOpening, TClosing> Observable<List<T>> buffer(ObservableSource<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>> closingIndicator) {
return this.buffer(openingIndicator, closingIndicator, ArrayListSupplier.asCallable());
}
@SchedulerSupport("none")
public final <TOpening, TClosing, U extends Collection<? super T>> Observable<U> buffer(ObservableSource<? extends TOpening> openingIndicator, Function<? super TOpening, ? extends ObservableSource<? extends TClosing>> closingIndicator, Callable<U> bufferSupplier) {
ObjectHelper.requireNonNull(openingIndicator, "openingIndicator is null");
ObjectHelper.requireNonNull(closingIndicator, "closingIndicator is null");
ObjectHelper.requireNonNull(bufferSupplier, "bufferSupplier is null");
return RxJavaPlugins.onAssembly(new ObservableBufferBoundary(this, openingIndicator, closingIndicator, bufferSupplier));
}
@SchedulerSupport("none")
public final <B> Observable<List<T>> buffer(ObservableSource<B> boundary) {
return this.buffer(boundary, ArrayListSupplier.asCallable());
}
@SchedulerSupport("none")
public final <B> Observable<List<T>> buffer(ObservableSource<B> boundary, int initialCapacity) {
return this.buffer(boundary, Functions.createArrayList(initialCapacity));
}
@SchedulerSupport("none")
public final <B, U extends Collection<? super T>> Observable<U> buffer(ObservableSource<B> boundary, Callable<U> bufferSupplier) {
ObjectHelper.requireNonNull(boundary, "boundary is null");
ObjectHelper.requireNonNull(bufferSupplier, "bufferSupplier is null");
return RxJavaPlugins.onAssembly(new ObservableBufferExactBoundary(this, boundary, bufferSupplier));
}
@SchedulerSupport("none")
public final <B> Observable<List<T>> buffer(Callable<? extends ObservableSource<B>> boundarySupplier) {
return this.buffer(boundarySupplier, ArrayListSupplier.asCallable());
}
@SchedulerSupport("none")
public final <B, U extends Collection<? super T>> Observable<U> buffer(Callable<? extends ObservableSource<B>> boundarySupplier, Callable<U> bufferSupplier) {
ObjectHelper.requireNonNull(boundarySupplier, "boundarySupplier is null");
ObjectHelper.requireNonNull(bufferSupplier, "bufferSupplier is null");
return RxJavaPlugins.onAssembly(new ObservableBufferBoundarySupplier(this, boundarySupplier, bufferSupplier));
}这里只简单示例：
Integer[] items = {1, 2, 3, 4, 5, 6};
Observable.fromArray(items).buffer(3).subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(Disposable disposable) {
System.out.println("onSubscribe");
}
@Override
public void onNext(List<Integer> integers) {
StringBuffer buffer = new StringBuffer();
buffer.append("收到的list为：{");
for (int i = 0; i < integers.size(); i++) {
buffer.append(integers.get(i));
if (i < integers.size() - 1) {
buffer.append(",");
}
}
buffer.append("}");
System.out.println(buffer.toString());
}
@Override
public void onError(Throwable throwable) {
System.out.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
});运行结果：
另外，再示例说明下 skip 参数，即再次分组时跳过的个数。
以下将 skip 分别设为2和3,，帮助理解：
Integer[] items = {1, 2, 3, 4, 5, 6};
Observable.fromArray(items).buffer(3,2).subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(Disposable disposable) {
System.out.println("onSubscribe");
}
@Override
public void onNext(List<Integer> integers) {
StringBuffer buffer = new StringBuffer();
buffer.append("收到的list为：{");
for (int i = 0; i < integers.size(); i++) {
buffer.append(integers.get(i));
if (i < integers.size() - 1) {
buffer.append(",");
}
}
buffer.append("}");
System.out.println(buffer.toString());
}
@Override
public void onError(Throwable throwable) {
System.out.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
}); Integer[] items = {1, 2, 3, 4, 5, 6};
Observable.fromArray(items).buffer(3,3).subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(Disposable disposable) {
System.out.println("onSubscribe");
}
@Override
public void onNext(List<Integer> integers) {
StringBuffer buffer = new StringBuffer();
buffer.append("收到的list为：{");
for (int i = 0; i < integers.size(); i++) {
buffer.append(integers.get(i));
if (i < integers.size() - 1) {
buffer.append(",");
}
}
buffer.append("}");
System.out.println(buffer.toString());
}
@Override
public void onError(Throwable throwable) {
System.out.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
});结果对比：
864
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
