文章目录
- 常用操作符
- 关于Rxjava2的操作符示例：
- Create
- just
- doOnNext
- 其余do类操作符：
- filter
- skip
- Flowable
- take
- distinct
- single
- concat
- merge/ mergeArray（）
- buffer
- map
- concatDelayError（） / mergeDelayError（）
- switchMap
- delay
- throttleFirst点击防止抖动
- timer(过时)
- interval
- defer
- reduce
- scan
- debounce
- window
- publishSubject
- asyncSubject
- BehaviorSubject
- Completable
- zip
- repeat
- 结合RxBing，通过combineLatest（）合并事件 & 联合判断
常用操作符
创建操作符
Create（）
private void rxCreate() {
Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
emitter.onComplete();
}
});
Observer<String> observer = new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.i(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
observable.subscribe(observer);
}
Just（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 15:38}
* @Description 创建一个被观察者，并发送事件，发送的事件不可以超过10个以上。
*/
private void initJust() {
Observable.just(1, 2, 3)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.toString());
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
fromArray（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 15:45}
* @Description 这个方法和 just() 类似，只不过 fromArray 可以传入多于10个的变量，并且可以传入一个数组。
*/
private void rxFromArray() {
Integer array[] = {1, 2, 3, 4};
Observable.fromArray(array)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.toString());
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
fromCallable（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 15:49}
* public static <T> Observable<T> fromCallable(Callable<? extends T> supplier)
* @Description 这里的 Callable 是 java.util.concurrent 中的 Callable，Callable 和 Runnable 的用法基本一致，
* 只是它会返回一个结果值，这个结果值就是发给观察者的。
*/
private void rxFromCallable() {
Observable.fromCallable(new Callable<Integer>() {
@Override
public Integer call() {
return 1;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
}
fromFuture（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 15:54}
* public static <T> Observable<T> fromFuture(Future<? extends T> future)
* @Description 参数中的 Future 是 java.util.concurrent 中的 Future，Future 的作用是增加了 cancel() 等方法操作 Callable，
* 它可以通过 get() 方法来获取 Callable 返回的值
*/
private void rxfromFuture() {
final FutureTask<String> futureTask = new FutureTask<>(new Callable<String>() {
@Override
public String call() throws Exception {
Log.i(TAG, "futureTask is running ");
return "futureTask 返回结果";
}
});
Observable.fromFuture(futureTask)
.doOnSubscribe(new Consumer<Disposable>() {
// doOnSubscribe() 的作用就是只有订阅时才会发送事件
@Override
public void accept(Disposable disposable) throws Exception {
futureTask.run();
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: " + s);
}
});
}
fromIterable（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:03}
* @Description public static <T> Observable<T> fromIterable(Iterable<? extends T> source)
* 直接发送一个 List 集合数据给观察者
*/
private void rxfromIterable() {
List<Integer> list = new ArrayList<>();
list.add(0);
list.add(1);
list.add(2);
list.add(3);
Observable.fromIterable(list)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
defer（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:06}
* public static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier)
* @Description 作用就是直到被观察者被订阅后才会创建被观察者
*/
private void rxdefer() {
Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> call() throws Exception {
return Observable.just(i);
}
});
i = 200;
Observer observer = new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
};
observable.subscribe(observer);
i = 300;
observable.subscribe(observer);
// 只有200和300会发送出去， defer() 只有观察者订阅的时候才会创建新的被观察者，所以每订阅一次就会打印一次，并且都是打印 i 最新的值。
}
timer（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:14}
* public static Observable<Long> timer(long delay, TimeUnit unit)
* @Description 当到指定时间后就会发送一个 0L 的值给观察者。
*/
private void rxtimer() {
Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long aLong) {
Log.i(TAG, "onNext: " + aLong);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
interval（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:17}
* public static Observable<Long> interval(long period, TimeUnit unit)
* public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit)
* @Description 每隔一段时间就会发送一个事件，这个事件是从0开始，不断增1的数字,可用来用网络轮询
*/
private void rxinterval() {
Observable.interval(2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Long aLong) {
Log.i(TAG, "onNext: " + aLong);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
intervalRange（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:23}
* public static Observable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit)
* public static Observable<Long> intervalRange(long start, long count, long initialDelay, long period, TimeUnit unit, Scheduler scheduler)
* @Description 可以指定发送事件的开始值和数量，其他与 interval() 的功能一样。
*/
private void rxintervalRange() {
Observable.intervalRange(2, 5, 2, 1, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Long aLong) {
Log.i(TAG, "onNext: " + aLong);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// 收到5次 onNext 事件，并且是从 2 开始,延迟2s,每隔1s发送一次
}
range（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:26}
* public static Observable<Integer> range(final int start, final int count)
* @Description 同时发送一定范围的事件序列
*/
private void rxrange() {
Observable.range(2, 5)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
rangeLong（）
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:29}
* public static Observable<Long> rangeLong(long start, long count)
* @Description 作用与 range() 一样，只是数据类型为 Long
*/
private void rxrangeLong() {
Observable.rangeLong(2, 5)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Long aLong) {
Log.i(TAG, "onNext: " + aLong);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
empty() & never() & error()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:31}
* empty() & never() & error()
* @Description onSubscribe是肯定会发送的
* empty() ： 直接发送 onComplete() 事件
* never()：不发送任何事件
* error()：发送 onError() 事件
*/
private void rxException() {
Observable.empty()
.subscribe(new Observer<Object>() {
@Override
public void onNext(Object o) {
Log.i(TAG, "onNext: ");
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
转换操作符
map()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:35}
* public final <R> Observable<R> map(Function<? super T, ? extends R> mapper)
* @Description map 可以将被观察者发送的数据类型转变成其他的类型
*/
private void rxmap() {
// Integer 类型的数据转换成 String
Observable.just(1, 2, 3)
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "字符串：" + integer;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.i(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
flatMap()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 16:39}
* public final <R> Observable<R> flatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper)
* @Description 可以将事件序列中的元素进行整合加工，返回一个新的被观察者（flatMap() 返回的是一个 Observerable）
*/
private void rxflatMap() {
Observable.fromIterable(personList)//发送person
.flatMap(new Function<Person, ObservableSource<Plan>>() {
@Override
public ObservableSource<Plan> apply(Person person) throws Exception {
return Observable.fromIterable(person.getPlanList());//将person变换成plan
}
})
.flatMap(new Function<Plan, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Plan plan) throws Exception {
return Observable.fromIterable(plan.getActionList());//将plan变换成自己的action，返回Observable
}
})
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.i(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
concatMap()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 17:04}
* public final <R> Observable<R> concatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper)
* public final <R> Observable<R> concatMap(Function<? super T, ? extends ObservableSource<? extends R>> mapper, int prefetch)
* @Description concatMap() 和 flatMap() 基本上是一样的，只不过 concatMap() 转发出来的事件是有序的，而 flatMap() 是无序的。
*/
private void rxconcatMap() {
Observable.fromIterable(personList)
.concatMap(new Function<Person, ObservableSource<Plan>>() {
@Override
public ObservableSource<Plan> apply(Person person) throws Exception {
if ("chan".equals(person.getName())) {
return Observable.fromIterable(person.getPlanList()).delay(10, TimeUnit.SECONDS);
}
return Observable.fromIterable(person.getPlanList());
}
}).subscribe(new Observer<Plan>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Plan plan) {
Log.i(TAG, "onNext: " + plan.getContent());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
buffer()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 17:13}
* public final Observable<List<T>> buffer(int count, int skip)
* @Description 从需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区当中一并发出。
* buffer 有两个参数，一个是 count，另一个 skip。count 缓冲区元素的数量，skip 就代表缓冲区满了之后，发送下一次事件序列的时候要跳过多少元素
*/
private void rxbuffer() {
Observable.just(1, 2, 3, 4, 5)
.buffer(2, 1)
.subscribe(new Observer<List<Integer>>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(List<Integer> integers) {
Log.i(TAG, "缓冲区大小: " + integers.size());
for (Integer i :
integers) {
Log.i(TAG, "onNext: " + i);
}
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
//I/MainActivity: 缓冲区大小: 2
//I/MainActivity: onNext: 1
//I/MainActivity: onNext: 2
//I/MainActivity: 缓冲区大小: 2
//I/MainActivity: onNext: 2
//I/MainActivity: onNext: 3
//I/MainActivity: 缓冲区大小: 2
//I/MainActivity: onNext: 3
//I/MainActivity: onNext: 4
//I/MainActivity: 缓冲区大小: 2
//I/MainActivity: onNext: 4
//I/MainActivity: onNext: 5
//I/MainActivity: 缓冲区大小: 1
//I/MainActivity: onNext: 5
groupBy()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 17:23}
* public final <K> Observable<GroupedObservable<K, T>> groupBy(Function<? super T, ? extends K> keySelector)
* @Description 将发送的数据进行分组，每个分组都会返回一个被观察者。
*/
private void rxgroupBy() {
Observable.just(5, 2, 3, 4, 1, 6, 8, 9, 7, 10)
.groupBy(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
return integer % 3;
}
}).subscribe(new Observer<GroupedObservable<Integer, Integer>>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(final GroupedObservable<Integer, Integer> integerIntegerGroupedObservable) {
Log.i(TAG, "onNext: ");
integerIntegerGroupedObservable.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "GroupedObservable onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "GroupedObservable onNext groupName: " + integerIntegerGroupedObservable.getKey() + "value:" + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "GroupedObservable onComplete: ");
}
});
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// I/MainActivity: GroupedObservable onNext groupName: 1value:1
// I/MainActivity: GroupedObservable onNext groupName: 0value:6
// I/MainActivity: GroupedObservable onNext groupName: 2value:8
// I/MainActivity: GroupedObservable onNext groupName: 0value:9
// I/MainActivity: GroupedObservable onNext groupName: 1value:7
// I/MainActivity: GroupedObservable onNext groupName: 1value:10
}
scan()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 17:32}
* public final Observable<T> scan(BiFunction<T, T, T> accumulator)
* @Description 将数据以一定的逻辑聚合起来。 每处理一次数据就会将事件发送给观察者
*/
private void rxscan() {
Observable.just(1, 2, 3, 4, 5)
.scan(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
Log.i(TAG, "====================apply ");
Log.i(TAG, "====================integer " + integer);
Log.i(TAG, "====================integer2 " + integer2);
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
// I/MainActivity: accept: 1
// I/MainActivity: ====================apply
// I/MainActivity: ====================integer 1
// I/MainActivity: ====================integer2 2
// I/MainActivity: accept: 3
// I/MainActivity: ====================apply
// I/MainActivity: ====================integer 3
// I/MainActivity: ====================integer2 3
// I/MainActivity: accept: 6
// I/MainActivity: ====================apply
// I/MainActivity: ====================integer 6
// I/MainActivity: ====================integer2 4
// I/MainActivity: accept: 10
// I/MainActivity: ====================apply
// I/MainActivity: ====================integer 10
// I/MainActivity: ====================integer2 5
// I/MainActivity: accept: 15
}
window()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 17:45}
* public final Observable<Observable<T>> window(long count)
* @Description 发送指定数量的事件时，就将这些事件分为一组。window 中的 count 的参数就是代表指定的数量，
* 例如将 count 指定为2，那么每发2个数据就会将这2个数据分成一组。
*/
private void rxwindow() {
Observable.just(1, 2, 3, 4, 5)
.window(2)
.subscribe(new Observer<Observable<Integer>>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Observable<Integer> integerObservable) {
integerObservable.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// 数据被分成了三组
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 3
// I/MainActivity: onNext: 4
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 5
}
组合操作符
concat()
/**
* @Author：yangtianfu
* @Date：{2019/4/10 18:00}
* public static <T> Observable<T> concat(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)
* @Description 可以将多个观察者组合在一起，然后按照之前发送顺序发送事件。需要注意的是，concat() 最多只可以发送4个事件
*/
private void rxconcat() {
Observable.concat(Observable.just(1, 2),
Observable.just(3, 4),
Observable.just(5, 6),
Observable.just(7, 8))
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
concatArray()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 9:17}
* public static <T> Observable<T> concatArray(ObservableSource<? extends T>... sources)
* @Description 与 concat() 作用一样，不过 concatArray() 可以发送多于 4 个被观察者。
*/
private void rxconcatArray() {
Observable.concatArray(Observable.just(1, 2),
Observable.just(3, 4),
Observable.just(5, 6),
Observable.just(7, 8),
Observable.just(9, 10))
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
merge & mergeArray()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 9:21}
* public static <T> Observable<T> merge(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2, ObservableSource<? extends T> source3, ObservableSource<? extends T> source4)
* @Description 这个方法月 concat() 作用基本一样，只是concat() 是串行发送事件，而 merge() 并行发送事件
* merge 只能发送不超过四个的被观察者，而MergeArray和merge作用一样，只是可以发送多于四个的Observeable
*/
private void rxmerge() {
Observable.merge(
Observable.interval(1, TimeUnit.SECONDS).map(new Function<Long, String>() {
@Override
public String apply(Long aLong) throws Exception {
return "A" + aLong;
}
}),
Observable.interval(1, TimeUnit.SECONDS).map(new Function<Long, String>() {
@Override
public String apply(Long aLong) throws Exception {
return "B" + aLong;
}
})
).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
Log.i(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// 、、、
// I/MainActivity: onNext: A3
// I/MainActivity: onNext: B3
// I/MainActivity: onNext: A4
// I/MainActivity: onNext: B4
// I/MainActivity: onNext: A5
// I/MainActivity: onNext: B5
// I/MainActivity: onNext: A6
// I/MainActivity: onNext: B6
// I/MainActivity: onNext: A7
// I/MainActivity: onNext: B7
// I/MainActivity: onNext: A8
// 、、、
}
concatArrayDelayError() & mergeArrayDelayError()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 9:33}
* public static <T> Observable<T> concatArrayDelayError(ObservableSource<? extends T>... sources)
* public static <T> Observable<T> mergeArrayDelayError(ObservableSource<? extends T>... sources)
* @Description 在 concatArray() 和 mergeArray() 两个方法当中，如果其中有一个被观察者发送了一个 Error 事件，那么就会停止发送事件，
* 如果你想 onError() 事件延迟到所有被观察者都发送完事件后再执行的话，就可以使用 concatArrayDelayError() 和 mergeArrayDelayError()
*/
private void rxconcatArrayDelayError() {
Observable.concatArrayDelayError(
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onError(new NullPointerException());
}
}),
Observable.just(2, 3, 4)
).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.toString());
}
@Override
public void onComplete() {
}
});
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onNext: 4
// E/MainActivity: onError: java.lang.NullPointerException
}
combineLatest()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 11:53}
* @Description combineLatest() 的作用与 zip() 类似，但是 combineLatest() 发送事件的序列是与发送的时间线有关的，
* 当 combineLatest() 中所有的 Observable 都发送了事件，只要其中有一个 Observable 发送事件，(zip是两个都发送)
* 这个事件就会和其他 Observable 最近发送的事件结合起来发送
* combineLatestDelayError() 是多了延迟发送 onError() 功能
*/
private void rxcombineLatest() {
Observable.combineLatest(
Observable.intervalRange(1, 4, 1, 1, TimeUnit.SECONDS)
.map(new Function<Long, String>() {
@Override
public String apply(Long aLong) throws Exception {
String s1 = "A" + aLong;
Log.i(TAG, "A 发送的事件: " + s1);
return s1;
}
}),
Observable.intervalRange(1, 5, 2, 2, TimeUnit.SECONDS)
.map(new Function<Long, String>() {
@Override
public String apply(Long aLong) throws Exception {
String s2 = "B" + aLong;
Log.i(TAG, "B 发送的事件: " + s2);
return s2;
}
}),
new BiFunction<String, String, String>() {
@Override
public String apply(String s, String s2) throws Exception {
String res = s + s2;
return res;
}
}
)
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.i(TAG, "最终接收到的事件onNext: " + s);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
reduce()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 13:27}
* public final Maybe<T> reduce(BiFunction<T, T, T> reducer)
* @Description 与 scan() 操作符的作用也是将发送数据以一定逻辑聚合起来，
* 这两个的区别在于 scan() 每处理一次数据就会将事件发送给观察者，而 reduce() 会将所有数据聚合在一起才会发送事件给观察者。
*/
private void rxreduce() {
Observable.just(0, 1, 2, 3)
.reduce(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) throws Exception {
int res = integer + integer2;
Log.i(TAG, "apply: " + integer);
Log.i(TAG, "apply2: " + integer2);
Log.i(TAG, "res: " + res);
return res;
}
})
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
}
);
// I/MainActivity: apply: 0
// I/MainActivity: apply2: 1
// I/MainActivity: res: 1
// I/MainActivity: apply: 1
// I/MainActivity: apply2: 2
// I/MainActivity: res: 3
// I/MainActivity: apply: 3
// I/MainActivity: apply2: 3
// I/MainActivity: res: 6
// I/MainActivity: accept: 6
}
collect()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 13:33}
* public final <U> Single<U> collect(Callable<? extends U> initialValueSupplier, BiConsumer<? super U, ? super T> collector)
* @Description 将数据收集到数据结构当中。
*/
private void rxcollect() {
Observable.just(1, 2, 3, 4)
.collect(new Callable<ArrayList<Integer>>() {
@Override
public ArrayList<Integer> call() throws Exception {
return new ArrayList<>();
}
},
new BiConsumer<ArrayList<Integer>, Integer>() {
@Override
public void accept(ArrayList<Integer> integers, Integer integer) throws Exception {
integers.add(integer);//将所有数据添加到数组中发送出去
}
}
).subscribe(new Consumer<ArrayList<Integer>>() {
@Override
public void accept(ArrayList<Integer> integers) throws Exception {
Log.i(TAG, "accept: " + integers);
// I/MainActivity: accept: [1, 2, 3, 4]
}
});
}
zip()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 10:06}
* public static <T1, T2, R> Observable<R> zip(ObservableSource<? extends T1> source1, ObservableSource<? extends T2> source2, BiFunction<? super T1, ? super T2, ? extends R> zipper)
* @Description 会将多个被观察者合并，根据各个被观察者发送事件的顺序一个个结合起来，
* 最终发送的事件数量会与源 Observable 中最少事件的数量一样
* 下边代码这会执行5次而不是6次，因为在第5次的时候第一个Observeable会在结束时发送onComplate事件
*/
private void rxzip() {
Observable.zip(Observable.intervalRange(1, 5, 1, 1, TimeUnit.SECONDS)
.map(new Function<Long, String>() {
@Override
public String apply(Long aLong) throws Exception {
String s1 = "A" + aLong;
Log.i(TAG, "apply: A发送");
return s1;
}
}),
Observable.intervalRange(1, 6, 1, 1, TimeUnit.SECONDS)
.map(new Function<Long, String>() {
@Override
public String apply(Long aLong) throws Exception {
String s2 = "B" + aLong;
Log.i(TAG, "apply: B发送");
return s2;
}
}),
new BiFunction<String, String, String>() {
@Override
public String apply(String s, String s2) throws Exception {
String res = s + s2;
return res;
}
}
)
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.i(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e.toString());
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
startWith() & startWithArray()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 13:41}
* public final Observable<T> startWith(T item)
* public final Observable<T> startWithArray(T... items)
* @Description 在发送事件之前追加事件，startWith() 追加一个事件，startWithArray() 可以追加多个事件。追加的事件会先发出。
*/
private void rxstartWithorArray() {
Observable.just(5, 6, 7)
.startWith(1)
.startWithArray(2, 3, 4)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
// I/MainActivity: accept: 2
// I/MainActivity: accept: 3
// I/MainActivity: accept: 4
// I/MainActivity: accept: 1
// I/MainActivity: accept: 5
// I/MainActivity: accept: 6
// I/MainActivity: accept: 7
}
count()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 13:46}
* public final Single<Long> count()
* @Description 仅仅返回被观察者发送事件的数量而不会发送事件
*/
private void rxcount() {
Observable.just(1, 2, 3)
.count()
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i(TAG, "accept: " + aLong);
}
});
// I/MainActivity: accept: 3
}
功能操作符
delay()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 13:53}
* public final Observable<T> delay(long delay, TimeUnit unit)
* @Description 延迟一段事件发送事件。
*/
private void rxdelay() {
Observable.just(1, 2, 3)
.delay(2, TimeUnit.SECONDS)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
// onSubscribe 回调2秒之后 onNext 才会回调
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
doOnEach()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 13:57}
* public final Observable<T> doOnEach(final Consumer<? super Notification<T>> onNotification)
* @Description Observable 每发送一件事件之前都会先回调这个方法。可以做一些前期配置操作
*/
private void rxdoOnEach() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
})
.doOnEach(new Consumer<Notification<Integer>>() {
@Override
public void accept(Notification<Integer> integerNotification) throws Exception {
Log.i(TAG, " doOnEach accept: " + integerNotification.getValue());
}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// 每发送一个事件之前都会回调 doOnEach 方法，并且可以取出 onNext() 发送的值。
// I/MainActivity: onSubscribe:
// I/MainActivity: doOnEach accept: 1
// I/MainActivity: onNext: 1
// I/MainActivity: doOnEach accept: 2
// I/MainActivity: onNext: 2
// I/MainActivity: doOnEach accept: 3
// I/MainActivity: onNext: 3
// I/MainActivity: doOnEach accept: null
// I/MainActivity: onComplete:
}
doOnNext()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 14:05}
* public final Observable<T> doOnNext(Consumer<? super T> onNext)
* @Description Observable 每发送 onNext() 之前都会先回调这个方法,只作用于onNext事件，doOnEeah作用于所有事件
*/
private void rxdoOnNext() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "doOnNext accept: " + integer);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
Log.d(TAG, "onError: ");
Log.v(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: doOnNext accept: 1
// I/MainActivity: onNext: 1
// I/MainActivity: doOnNext accept: 2
// I/MainActivity: onNext: 2
// I/MainActivity: doOnNext accept: 3
// I/MainActivity: onNext: 3
// I/MainActivity: onComplete:
}
doAfterNext()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 14:20}
* public final Observable<T> doAfterNext(Consumer<? super T> onAfterNext)
* @Description Observable 每发送 onNext() 之后都会回调这个方法。
*/
private void rxdoAfterNext() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doAfterNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "doAfterNext accept: " + integer);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: ", e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: doAfterNext accept: 1
// I/MainActivity: onNext: 2
// I/MainActivity: doAfterNext accept: 2
// I/MainActivity: onNext: 3
// I/MainActivity: doAfterNext accept: 3
// I/MainActivity: onComplete:
}
doOnComplete（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 14:29}
* public final Observable<T> doOnComplete(Action onComplete)
* @Description 发送OnComplete()之前发送
*/
private void rxdoOnComplete() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doOnComplete(new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "doOnComplete run: ");
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: ", e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: doOnComplete run:
// I/MainActivity: onComplete:
}
doOnError（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 14:38}
* public final Observable<T> doOnError(Consumer<? super Throwable> onError)
* @Description Observable 每发送 onError() 之前都会回调这个方法。
*/
private void rxdoOnError() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new NullPointerException());
}
}).doOnError(new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.i(TAG, "doOnError accept: " + throwable);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: doOnError accept: java.lang.NullPointerException
// I/MainActivity: onError:
});
}
doOnSubscribe（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 15:37}
* public final Observable<T> doOnSubscribe(Consumer<? super Disposable> onSubscribe)
* @Description Observable 每发送 onSubscribe() 之前都会回调这个方法。
*/
private void rxdoOnSubscribe() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
Log.i(TAG, " doOnSubscribe accept: ");
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: doOnSubscribe accept:
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onComplete:
});
}
doOnDispose
/**
* @Author：yangtianfu
* @Date：{2019/4/11 15:54}
* public final Observable<T> doOnDispose(Action onDispose)
* @Description 当调用 Disposable 的 dispose() 之后回调该方法。
*/
private void rxdoOnDispose() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doOnDispose(new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "run: doOnDispose");
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
disposable = d;
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
disposable.dispose();
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: run: doOnDispose
}
doOnLifecycle()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 16:00}
* public final Observable<T> doOnLifecycle(final Consumer<? super Disposable> onSubscribe, final Action onDispose)
* @Description 在回调 onSubscribe 之前回调该方法的第一个参数的回调方法，可以使用该回调方法决定是否取消订阅
* doOnLifecycle() 第二个参数的回调方法的作用与 doOnDispose() 是一样的
*/
private void rxdoOnLifecycle() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doOnLifecycle(
// 第一个参数，可以用来取消订阅
new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
// 如果在此处取消订阅，doOnDispose Action 和 doOnLifecycle Action 都不会被回调
Log.i(TAG, "accept: doOnLifecycle");
}
},
// 第二个参数作用等同于doOnDispose,取消订阅后执行此回调
new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "run: doOnLifecycle");
}
}
).doOnDispose(new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "run: doOnDispose");
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
disposable = d;
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
disposable.dispose();
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// 在 onNext() 方法进行取消订阅操作后，doOnDispose() 和 doOnLifecycle() 都会被回调。
// I/MainActivity: accept: doOnLifecycle
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: run: doOnDispose
// I/MainActivity: run: doOnLifecycle
// 如果使用 doOnLifecycle 进行取消订阅,doOnDispose Action 和 doOnLifecycle Action 都没有被回调
});
}
doOnTerminate（）& doAfterTerminate（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 16:13}
* public final Observable<T> doOnTerminate(final Action onTerminate)
* public final Observable<T> doAfterTerminate(Action onFinally)
* @Description doOnTerminate 是在 onError 或者 onComplete 发送之前回调，
* 而 doAfterTerminate 则是 onError 或者 onComplete 发送之后回调。
*/
private void rxdoOnTerminate() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onError(new NullPointerException());
// emitter.onComplete();
}
}).doOnTerminate(new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "run: doOnTerminate");
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: run: doOnTerminate
// I/MainActivity: onError:
});
}
doFinally（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 16:19}
* public final Observable<T> doFinally(Action onFinally)
* @Description 在所有事件发送完毕之后回调该方法。
* 取消订阅之后 doAfterTerminate() 不会被回调，而 doFinally() 无论怎么样都会被回调，且都会在事件序列的最后。
*/
private void rxdoFinally() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).doFinally(new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "run: doFinally");
}
}).doOnDispose(new Action() {
@Override
public void run() throws Exception {
Log.i(TAG, "run: doOnDispose");
}
}).doAfterTerminate(new Action() {
@Override
public void run() throws Exception {
// 如果调用了 dispose() 方法，doAfterTerminate() 不会被回调。
Log.i(TAG, "run: doAfterTerminate");
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
disposable = d;
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
// 如果调用了 dispose() 方法，doAfterTerminate() 不会被回调。
// disposable.dispose(); 注释这里才会执行doAfterTerminate()
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: run: doOnDispose
// I/MainActivity: run: doFinally
});
}
onErrorReturn（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 16:44}
* public final Observable<T> onErrorReturn(Function<? super Throwable, ? extends T> valueSupplier)
* @Description 当接受到一个 onError() 事件之后回调，返回的值会回调 onNext() 方法，并正常结束该事件序列
*/
private void rxonErrorReturn() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new NullPointerException());
}
}).onErrorReturn(new Function<Throwable, Integer>() {
@Override
public Integer apply(Throwable throwable) throws Exception {
Log.i(TAG, "apply: onErrorReturn");
return 404;
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: apply: onErrorReturn
// I/MainActivity: onNext: 404
// I/MainActivity: onComplete:
});
}
onErrorResumeNext（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 16:49}
* public final Observable<T> onErrorResumeNext(Function<? super Throwable, ? extends ObservableSource<? extends T>> resumeFunction)
* @Description 当接收到 onError() 事件时，返回一个新的 Observable，并正常结束事件序列。
*/
private void rxOnErrorResumeNext() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new NullPointerException());
}
}).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {
Log.i(TAG, "apply: onErrorResumeNext" + throwable);
return Observable.just(4, 5, 6);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: apply: onErrorResumeNextjava.lang.NullPointerException
// I/MainActivity: onNext: 4
// I/MainActivity: onNext: 5
// I/MainActivity: onNext: 6
// I/MainActivity: onComplete:
});
}
onExceptionResumeNext（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 16:54}
* public final Observable<T> onExceptionResumeNext(final ObservableSource<? extends T> next)
* @Description 与 onErrorResumeNext() 作用基本一致，但是这个方法只能捕捉 Exception。
*/
private void rxOnExceptionResumeNext() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new Exception("404"));
}
}).onExceptionResumeNext(new Observable<Integer>() {
@Override
protected void subscribeActual(Observer<? super Integer> observer) {
observer.onNext(333);
observer.onComplete();
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
retry（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 16:59}
* public final Observable<T> retry(long times)
* @Description 如果出现错误事件，则会重新发送所有事件序列。times 是代表重新发的次数。
*/
private void rxretry() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new Exception("404"));
}
}).retry(2)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onError:
});
}
retryUntil（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 17:03}
* public final Observable<T> retryUntil(final BooleanSupplier stop)
* @Description 出现错误事件之后，可以通过此方法判断是否继续发送事件。
*/
private void rxretryUntil() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new Exception("404"));
}
}).retryUntil(new BooleanSupplier() {
@Override
public boolean getAsBoolean() throws Exception {
// 这里判断是否继续发送事件。返回true表示停止发送，如果一直返回false，就会一直发送，可以做断网重连操作
if (i == 100) {
return true;
}
return false;
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
}
retryWhen（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 17:12}
* public final void safeSubscribe(Observer<? super T> s)
* @Description 当被观察者接收到异常或者错误事件时会回调该方法，这个方法会返回一个新的被观察者。
* 如果返回的被观察者发送 Error 事件则之前的被观察者不会继续发送事件，
* 如果发送正常事件则之前的被观察者会继续不断重试发送事件
*/
private void rxretryWhen() {
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("chan");
emitter.onNext("ze");
emitter.onNext("de");
// emitter.onError(new Exception("404"));//异常忽略，一直发送
emitter.onError(new Exception("303"));//终止发送
emitter.onNext("haha");
}
}).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(final Observable<Throwable> throwableObservable) throws Exception {
return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(Throwable throwable) throws Exception {
Log.i(TAG, "apply: throwableObservable:" + throwable);
if (throwable.toString().equals("java.lang.Exception: 404")) {
// 之前的被观察者会继续发送事件
return Observable.just("可以忽略的异常");
} else {
// 发送 Error 事件则之前的被观察者不会继续发送事件
return Observable.error(new Throwable("终止啦"));
}
}
});
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.i(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: " + e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: chan
// I/MainActivity: onNext: ze
// I/MainActivity: onNext: de
// I/MainActivity: apply: throwableObservable:java.lang.Exception: 303
// I/MainActivity: onError: java.lang.Throwable: 终止啦
});
}
repeat（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 17:35}
* public final Observable<T> repeat(long times)
* 重复发送被观察者的事件，times 为发送次数。
* @Description
*/
private void rxrepeat() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).repeat(2)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: " + e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onComplete:
}
retryWhen（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 17:40}
* public final Observable<T> repeatWhen(final Function<? super Observable<Object>, ? extends ObservableSource<?>> handler)
* @Description 这个方法可以会返回一个新的被观察者设定一定逻辑来决定是否重复发送事件。
* 如果新的被观察者返回 onComplete 或者 onError 事件，则旧的被观察者不会继续发送事件。
* 如果被观察者返回其他事件，则会重复发送事件。
*/
private void rxrepeatWhen() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {
return Observable.empty();
// return Observable.error(new Exception("404"));
// return Observable.just(4);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: " + e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
// I/MainActivity: onSubscribe:
// I/MainActivity: onComplete:
});
}
subscribeOn（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 17:47}
* public final Observable<T> subscribeOn(Scheduler scheduler)
* @Description 指定被观察者的线程，要注意的时，如果多次调用此方法，只有第一次有效
*/
private void rxsubscribeOn() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
Log.i(TAG, "subscribe: =currentThread name: " + Thread.currentThread().getName());
// 不设定线程默认是在main（主）线程
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
}).subscribeOn(Schedulers.newThread())
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: " + e);
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: subscribe: =currentThread name: RxNewThreadScheduler-1
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onComplete
}
observeOn（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 17:54}
* public final Observable<T> observeOn(Scheduler scheduler)
* @Description 指定观察者的线程，每指定一次就会生效一次。
*/
private void rxobserveOn() {
Observable.just(1, 2, 3)
.observeOn(Schedulers.newThread())
.flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
Log.i(TAG, "======================flatMap Thread name " + Thread.currentThread().getName());
return Observable.just("chan" + integer);
}
}).observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(String s) {
Log.i(TAG, "onNext: Thread name " + Thread.currentThread().getName());
Log.i(TAG, "onNext: " + s);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: ======================flatMap Thread name RxNewThreadScheduler-1
// I/MainActivity: ======================flatMap Thread name RxNewThreadScheduler-1
// I/MainActivity: onNext: Thread name main
// I/MainActivity: onNext: chan1
// I/MainActivity: onNext: Thread name main
// I/MainActivity: onNext: chan2
// I/MainActivity: onNext: Thread name main
// I/MainActivity: onNext: chan3
// I/MainActivity: onComplete:
// 调度器 作用
// Schedulers.computation( ) 用于使用计算任务，如事件循环和回调处理
// Schedulers.immediate( ) 当前线程
// Schedulers.io( ) 用于 IO 密集型任务，如果异步阻塞 IO 操作。
// Schedulers.newThread( ) 创建一个新的线程
// AndroidSchedulers.mainThread() Android 的 UI 线程，用于操作 UI。
}
过滤操作符
filter（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:04}
* public final Observable<T> filter(Predicate<? super T> predicate)
* @Description 通过一定逻辑来过滤被观察者发送的事件，如果返回 true 则会发送事件，否则不会发送。
*/
private void rxfilter() {
Observable.just(1, 2, 3)
.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer < 2;
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onComplete:
}
ofType（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:08}
* public final <U> Observable<U> ofType(final Class<U> clazz)
* @Description 可以过滤不符合该类型事件
*/
private void rxofType() {
Observable.just(1, 2, 3, "chan", "zhide")
.ofType(Integer.class)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onComplete:
}
skip（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:11}
* public final Observable<T> skip(long count)
* @Description 跳过正序某些事件，count 代表跳过事件的数量
* skipLast() 作用也是跳过某些事件，不过它是用来跳过正序的后面的事件
*/
private void rxskip() {
Observable.just(1, 2, 3)
.skip(2)//跳过前边两个
// .skipLast(1)//跳过最后一个
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer integer) {
// i += integer;
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// I/MainActivity: onSubscribe:
// I/MainActivity: onNext: 3
}
distinct()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:17}
* public final Observable<T> distinct()
* @Description 过滤事件序列中的重复事件。
*/
private void rxdistinct() {
Observable.just(1, 2, 3, 3, 2, 1)
.distinct()
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
}
distinctUntilChanged()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:20}
* public final Observable<T> distinctUntilChanged()
* @Description 过滤掉连续重复的事件
*/
private void rxdistinctUntilChanged() {
Observable.just(1, 2, 3, 3, 2, 1)
.distinctUntilChanged()
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 1
}
take（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:23}
* public final Observable<T> take(long count)
* @Description 控制观察者接收的事件的数量。
*/
private void rxtake() {
Observable.just(1, 2, 3, 4, 5)
.take(3)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// I/MainActivity: onNext: 1
// I/MainActivity: onNext: 2
// I/MainActivity: onNext: 3
}
debounce（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:26}
* public final Observable<T> debounce(long timeout, TimeUnit unit)
* @Description 如果两件事件发送的时间间隔小于设定的时间间隔则前一件事件就不会发送给观察者。
* 如果有多个事件都是小于设定的时间间隔，只会发送最后一次的数据，处理手机卡顿连续点击多次跳转问题
*/
private void rxdebounce() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
Thread.sleep(900);
emitter.onNext(2);
}
}).debounce(1, TimeUnit.SECONDS)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "onNext: " + integer);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// I/MainActivity: onNext: 2
}
firstElement() & lastElement()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:31}
* public final Maybe<T> firstElement()
* public final Maybe<T> lastElement()
* @Description firstElement() 取事件序列的第一个元素，lastElement() 取事件序列的最后一个元素。
*/
private void rxfirstElement() {
Observable.just(1, 2, 3, 4)
.firstElement()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: firstElement" + integer);
}
});
Observable.just(1, 2, 3, 4)
.lastElement()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: lastElement" + integer);
}
});
// I/MainActivity: accept: firstElement1
// I/MainActivity: accept: lastElement4
}
elementAt() & elementAtOrError()
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:35}
* public final Maybe<T> elementAt(long index)
* public final Single<T> elementAtOrError(long index)
* @Description elementAt() 可以指定取出事件序列中事件，但是输入的 index 超出事件序列的总数的话就不会出现任何结果。
* 这种情况下，你想发出异常信息的话就用 elementAtOrError() 。
*/
private void rxelementAt() {
Observable.just(1, 2, 3, 4)
.elementAt(0)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
// Observable.just(1, 2, 3, 4)
// .elementAtOrError(5)
// .subscribe(new Consumer<Integer>() {
// @Override
// public void accept(Integer integer) throws Exception {
抛出 NoSuchElementException 异常
// Log.i(TAG, "accept: "+integer);
// }
// });
}
条件操作符
all（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:39}
* public final Observable<T> ambWith(ObservableSource<? extends T> other)
* @Description 判断事件序列是否全部满足某个事件，如果都满足则返回 true，反之则返回 false。
*/
private void rxall() {
Observable.just(1, 2, 3, 4)
.all(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer < 5;
}
}).subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i(TAG, "accept: " + aBoolean);
}
});
}
takeWhile（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:42}
* public final Observable<T> takeWhile(Predicate<? super T> predicate)
* @Description 可以设置条件，当某个数据满足条件时就会发送该数据，反之则不发送。
*/
private void rxtakeWhile() {
Observable.just(1, 2, 3, 4)
.takeWhile(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer < 3;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
// I/MainActivity: accept: 1
// I/MainActivity: accept: 2
}
takeUntil（）
/**
* @Author：yangtianfu
* @Date：{2019/4/11 18:45}
* public final Observable<T> takeUntil(Predicate<? super T> stopPredicate
* @Description 可以设置条件，当事件满足此条件时，下一次的事件就不会被发送了。
*/
private void rxtakeUtil() {
Observable.just(1, 2, 3, 4, 5, 6)
.takeUntil(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer > 3;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
// I/MainActivity: accept: 1
// I/MainActivity: accept: 2
// I/MainActivity: accept: 3
// I/MainActivity: accept: 4
}
skipWhile（）
/**
* @Author：yangtianfu
* @Date：{2019/4/12 9:40}
* public final Observable<T> skipWhile(Predicate<? super T> predicate
* @Description 和takeWhile相反，当某个数据满足条件时不发送该数据，反之则发送。
*/
private void rxskipWhile() {
Observable.just(1, 2, 3, 4)
.skipWhile(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) throws Exception {
return integer < 3;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
// I/MainActivity: accept: 3
// I/MainActivity: accept: 4
}
skipUntil（）
/**
* @Author：yangtianfu
* @Date：{2019/4/12 9:46}
* @Description 当 skipUntil() 中的 Observable 发送事件了，原来的 Observable 才会发送事件给观察者。
* skipUntil() 里的 Observable 并不会发送事件给观察者。
*/
private void rxskipUtil() {
Observable.intervalRange(1, 5, 0, 1, TimeUnit.SECONDS)
.skipUntil(Observable.intervalRange(6, 5, 3, 1, TimeUnit.SECONDS))
// 表示3s后开始发送事件，而自身不发送事件
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i(TAG, "accept: ");
}
});
}
sequenceEqual（）
/**
* @Author：yangtianfu
* @Date：{2019/4/12 10:02}
* public static <T> Single<Boolean> sequenceEqual(ObservableSource<? extends T> source1, ObservableSource<? extends T> source2)
* @Description 判断两个 Observable 发送的事件是否相同。
*/
private void rxsequenceEqual() {
Observable.sequenceEqual(Observable.just(1, 2, 3), Observable.just(1, 2, 3))
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i(TAG, "accept: " + aBoolean);
}
// I/MainActivity: accept: true
});
}
contains（）
/**
* @Author：yangtianfu
* @Date：{2019/4/12 10:05}
* public final Single<Boolean> contains(final Object element)
* @Description 判断事件序列中是否含有某个元素，如果有则返回 true，如果没有则返回 false。
*/
private void rxcontains() {
Observable.just(1, 2, 3)
.contains(3)
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i(TAG, "accept: " + aBoolean);
}
});
}
isEmpty()
/**
* @Author：yangtianfu
* @Date：{2019/4/12 10:07}
* public final Single<Boolean> isEmpty()
* @Description 判断事件序列是否为空。
*/
private void rxisEmpty() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onComplete();
}
}).isEmpty()
.subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
Log.i(TAG, "accept: " + aBoolean);
// I/MainActivity: accept: true
}
});
}
/**
* @Author：yangtianfu
* @Date：{2019/4/12 10:11}
* public static <T> Observable<T> amb(Iterable<? extends ObservableSource<? extends T>> sources)
* @Description amb() 要传入一个 Observable 集合，但是只会发送最先发送事件的 Observable 中的全部事件，
* 其余 Observable 将会被丢弃，一个事件也不会发送。
*/
private void rxamb() {
ArrayList<Observable<Long>> list = new ArrayList<>();
list.add(Observable.intervalRange(1, 5, 2, 1, TimeUnit.SECONDS));
list.add(Observable.intervalRange(6, 5, 0, 1, TimeUnit.SECONDS));
Observable.amb(list)
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
Log.i(TAG, "accept: " + aLong);
}
});
// I/MainActivity: accept: 6
// I/MainActivity: accept: 7
// I/MainActivity: accept: 8
// I/MainActivity: accept: 9
// I/MainActivity: accept: 10
}
defaultIfEmpty（）
/**
* @Author：yangtianfu
* @Date：{2019/4/12 10:15}
* public final Observable<T> defaultIfEmpty(T defaultItem)
* @Description 如果观察者只发送一个 onComplete() 事件，则可以利用这个方法发送一个值
*/
private void rxdefaultEmpty() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onComplete();
}
}).defaultIfEmpty(666)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
}
});
}
关于Rxjava2的操作符示例：
Create
用于获取一个被观察者对象,统一把被观察者 Observable 称为发射器（上游事件），观察者 Observer 称为接收器（下游事件）。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
mRxOperatorsText.append("Observable emit 1" + "\n");
Log.e(TAG, "Observable emit 1" + "\n");
e.onNext(1);
mRxOperatorsText.append("Observable emit 2" + "\n");
Log.e(TAG, "Observable emit 2" + "\n");
e.onNext(2);
mRxOperatorsText.append("Observable emit 3" + "\n");
Log.e(TAG, "Observable emit 3" + "\n");
e.onNext(3);
e.onComplete();
mRxOperatorsText.append("Observable emit 4" + "\n");
Log.e(TAG, "Observable emit 4" + "\n" );
e.onNext(4);
}
}).subscribe(new Observer<Integer>() {
private int i;
private Disposable mDisposable;
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("onSubscribe : " + d.isDisposed() + "\n");
Log.e(TAG, "onSubscribe : " + d.isDisposed() + "\n" );
mDisposable = d;
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("onNext : value : " + integer + "\n");
Log.e(TAG, "onNext : value : " + integer + "\n" );
i++;
if (i == 2) {
// 在RxJava 2.x 中，新增的Disposable可以做到切断的操作，让Observer观察者不再接收上游事件
mDisposable.dispose();
mRxOperatorsText.append("onNext : isDisposable : " + mDisposable.isDisposed() + "\n");
Log.e(TAG, "onNext : isDisposable : " + mDisposable.isDisposed() + "\n");
}
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("onError : value : " + e.getMessage() + "\n");
Log.e(TAG, "onError : value : " + e.getMessage() + "\n" );
}
@Override
public void onComplete() {
mRxOperatorsText.append("onComplete" + "\n");
Log.e(TAG, "onComplete" + "\n" );
}
});
just
接受一个可变参数，依次发送,RxJava 2.x 新增Consumer，可自定义实现，accept 里面相当于原本的onNext，就是一个简单的发射器依次调用 onNext() 方法。
Observable.just("1", "2", "3")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("accept : onNext : " + s + "\n");
Log.e(TAG,"accept : onNext : " + s + "\n" );
}
});
doOnNext
让订阅者在接收到数据前干点事情的操作符,比如我们在获取到数据之前想先保存一下它
Observable.just(1, 2, 3, 4)
.doOnNext(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("doOnNext 保存 " + integer + "成功" + "\n");
Log.e(TAG, "doOnNext 保存 " + integer + "成功" + "\n");
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("doOnNext :" + integer + "\n");
Log.e(TAG, "doOnNext :" + integer + "\n");
}
});
其余do类操作符：
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new Throwable("发生错误了"));
}
})
// 1. 当Observable每发送1次数据事件就会调用1次
.doOnEach(new Consumer<Notification<Integer>>() {
@Override
public void accept(Notification<Integer> integerNotification) throws Exception {
Log.d(TAG, "doOnEach: " + integerNotification.getValue());
}
})
// 2. 执行Next事件前调用
.doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "doOnNext: " + integer);
}
})
// 3. 执行Next事件后调用
.doAfterNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "doAfterNext: " + integer);
}
})
// 4. Observable正常发送事件完毕后调用
.doOnComplete(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doOnComplete: ");
}
})
// 6. 观察者订阅时调用
.doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
Log.e(TAG, "doOnSubscribe: ");
}
})
// 7. Observable发送事件完毕后调用，无论正常发送完毕 / 异常终止
.doAfterTerminate(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doAfterTerminate: ");
}
})
// 8. 最后执行
.doFinally(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doFinally: ");
}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.d(TAG, "接收到了事件"+ integer );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
filter
过滤操作符，取正确的值,过滤掉不符合我们条件的值,只接受满足filter条件的值发送给下游事件
Observable.just(1, 20, 65, -5, 7, 19)
.filter(new Predicate<Integer>() {
@Override
public boolean test(@NonNull Integer integer) throws Exception {
return integer >= 10;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("filter : " + integer + "\n");
Log.e(TAG, "filter : " + integer + "\n");
}
});
skip
接受一个long型参数，代表跳过 count 个数目开始接收。
Observable.just(1,2,3,4,5)
.skip(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("skip : "+integer + "\n");
Log.e(TAG, "skip : "+integer + "\n");
}
});
Flowable
专用于解决背压问题Backpressure，在异步场景中，被观察者发送事件的速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略
Flowable.just(1,2,3,4)
.reduce(100, new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
return integer+integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("Flowable :"+integer+"\n");
Log.e(TAG, "Flowable :"+integer+"\n" );
}
});
take
用于指定订阅者最多收到多少数据
Flowable.fromArray(1,2,3,4,5)
.take(2)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("take : "+integer + "\n");
Log.e(TAG, "accept: take : "+integer + "\n" );
}
});
>倒计时：
final int count =11;
Observable.interval(0,1,TimeUnit.SECONDS)
.take(count)
.map(new Function<Long, Long>() {
@Override
public Long apply(Long aLong) throws Exception {
return count - aLong;
}
})
.observeOn(AndroidSchedulers.mainThread())
.doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(Disposable disposable) throws Exception {
mButtonSend.setEnabled(false);
mButtonSend.setTextColor(Color.BLACK);
}
})
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long aLong) {
mButtonSend.setText("剩余 "+ aLong +" 秒");
}
@Override
public void onError(Throwable e) {
e.printStackTrace();
}
@Override
public void onComplete() {
mButtonSend.setEnabled(true);
mButtonSend.setTextColor(Color.WHITE);
mButtonSend.setText("发生验证码");
}
});
distinct
去重操作符，其实就是简单的去重
Observable.just(1, 1, 1, 2, 2, 3, 4, 5)
.distinct()
.subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("distinct : " + integer + "\n");
Log.e(TAG, "distinct : " + integer + "\n");
}
});
single
顾名思义，Single只会接收一个参数,而SingleObserver只会调用onError或者onSuccess
Single.just(new Random().nextInt())
.subscribe(new SingleObserver<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onSuccess(@NonNull Integer integer) {
mRxOperatorsText.append("single : onSuccess : "+integer+"\n");
Log.e(TAG, "single : onSuccess : "+integer+"\n" );
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("single : onError : "+e.getMessage()+"\n");
Log.e(TAG, "single : onError : "+e.getMessage()+"\n");
}
});
concat
连接操作符，可接受Observable的可变参数，或者Observable的集合
利用 concat 的必须调用 onComplete 后才能订阅下一个 Observable 的特性，我们就可以先读取缓存数据，倘若获取到的缓存数据不是我们想要的，再调用 onComplete() 以执行获取网络数据的 Observable，如果缓存数据能应我们所需，则直接调用 onNext()，防止过度的网络请求，浪费用户的流量。
Observable.concat(Observable.just(1,2,3), Observable.just(4,5,6))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("concat : "+ integer + "\n");
Log.e(TAG, "concat : "+ integer + "\n" );
}
});
示例：从磁盘 / 内存缓存中 获取缓存数据
public class UsageDemo1 extends AppCompatActivity {
// 该2变量用于模拟内存缓存 & 磁盘缓存中的数据
String memoryCache = null;
String diskCache = "从磁盘缓存中获取数据";
private String TAG = "RxJava";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_combine);
/*
* 设置第1个Observable：检查内存缓存是否有该数据的缓存
**/
Observable<String> memory = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
// 先判断内存缓存有无数据
if (memoryCache != null) {
// 若有该数据，则发送
emitter.onNext(memoryCache);
} else {
// 若无该数据，则直接发送结束事件
emitter.onComplete();
}
}
});
/*
* 设置第2个Observable：检查磁盘缓存是否有该数据的缓存
**/
Observable<String> disk = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
// 先判断磁盘缓存有无数据
if (diskCache != null) {
// 若有该数据，则发送
emitter.onNext(diskCache);
} else {
// 若无该数据，则直接发送结束事件
emitter.onComplete();
}
}
});
/*
* 设置第3个Observable：通过网络获取数据
**/
Observable<String> network = Observable.just("从网络中获取数据");
// 此处仅作网络请求的模拟
/*
* 通过concat（） 和 firstElement（）操作符实现缓存功能
**/
// 1. 通过concat（）合并memory、disk、network 3个被观察者的事件（即检查内存缓存、磁盘缓存 & 发送网络请求）
// 并将它们按顺序串联成队列
Observable.concat(memory, disk, network)
// 2. 通过firstElement()，从串联队列中取出并发送第1个有效事件（Next事件），即依次判断检查memory、disk、network
.firstElement()
// 即本例的逻辑为：
// a. firstElement()取出第1个事件 = memory，即先判断内存缓存中有无数据缓存；由于memoryCache = null，即内存缓存中无数据，所以发送结束事件（视为无效事件）
// b. firstElement()继续取出第2个事件 = disk，即判断磁盘缓存中有无数据缓存：由于diskCache ≠ null，即磁盘缓存中有数据，所以发送Next事件（有效事件）
// c. 即firstElement()已发出第1个有效事件（disk事件），所以停止判断。
// 3. 观察者订阅
.subscribe(new Consumer<String>() {
@Override
public void accept( String s) throws Exception {
Log.d(TAG,"最终获取的数据来源 = "+ s);
}
});
}
}
merge/ mergeArray（）
将多个Observable合起来，接受可变参数，也支持使用迭代器集合,注意它和 concat 的区别在于，不用等到 发射器 A 发送完所有的事件再进行发射器 B 的发送。
二者区别：组合被观察者的数量，即merge（）组合被观察者数量≤4个，而mergeArray（）则可＞4个
区别上述concat（）操作符：同样是组合多个被观察者一起发送数据，但concat（）操作符合并后是按发送顺序串行执行
Observable.merge(Observable.just(1, 2), Observable.just(3, 4, 5))
.subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("merge :" + integer + "\n");
Log.e(TAG, "accept: merge :" + integer + "\n" );
}
});
合并数据源
public class UsageDemo2 extends AppCompatActivity {
private String TAG = "RxJava";
// 用于存放最终展示的数据
private String result = "数据源来自 = " ;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_combine);
/*
* 设置第1个Observable：通过网络获取数据
* 此处仅作网络请求的模拟
**/
Observable<String> network = Observable.just("网络");
/*
* 设置第2个Observable：通过本地文件获取数据
* 此处仅作本地文件请求的模拟
**/
Observable<String> file = Observable.just("本地文件");
/*
* 通过merge（）合并事件 & 同时发送事件
**/
Observable.merge(network, file)
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.d(TAG, "数据源有： "+ value );
result += value + "+";
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
// 接收合并事件后，统一展示
@Override
public void onComplete() {
Log.d(TAG, "获取数据完成");
Log.d(TAG, result );
}
});
}
}
合并本地和网络数据
public void click(View view) {
Observable.merge(getDatasFromLocal(),getDatasFromNetWork())
.subscribe(new Consumer<List<Course>>() {
@Override
public void accept(List<Course> courses) throws Exception {
// 合并后数据 courses
}
});
}
/**
* 模拟本地数据
* @return
*/
private Observable<List<Course>> getDatasFromLocal(){
List<Course> list = new ArrayList<>();
list.add(new Course("菜鸟商城"));
list.add(new Course("菜鸟新闻"));
return Observable.just(list);
}
/**
* 模拟网络数据
* @return
*/
private Observable<List<Course>> getDatasFromNetWork(){
return api.getCourse().subscribeOn(Schedulers.io());
// List<Course> list = new ArrayList<>();
// list.add(new Course("菜鸟直播"));
// list.add(new Course("菜鸟手机助手"));
// return Observable.just(list);
}
buffer
buffer(count, skip)` 从定义就差不多能看出作用了，将 observable 中的数据按 skip（步长）分成最长不超过 count 的 buffer，然后生成一个 observable
Observable.just(1, 2, 3, 4, 5)
.buffer(3, 2)//生成buffer长度最长为3，步长为2
.subscribe(new Consumer<List<Integer>>() {
@Override
public void accept(@NonNull List<Integer> integers) throws Exception {
mRxOperatorsText.append("buffer size : " + integers.size() + "\n");
mRxOperatorsText.append("buffer value : ");
for (Integer i : integers) {
mRxOperatorsText.append(i + "");
}
mRxOperatorsText.append("\n");
Log.e(TAG, "\n");
}
});
我们把 1, 2, 3, 4, 5 依次发射出来，经过 buffer 操作符，其中参数 skip 为 2， count 为 3，而我们的输出 依次是 123，345，5。显而易见，我们 buffer 的第一个参数是 count，代表最大取值，在事件足够的时候，一般都是取 count 个值，然后每次跳过 skip 个事件。
map
基本是RxJava 最简单的操作符了作用是对上游发送的每一个事件应用一个函数,使得每一个事件都按照指定的函数去变化，用于进行网络数据解析
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function<Integer, String>() {
//将上游事件放入function函数中处理，接受两个参数，Integer是接受的事件类型，String是返回类型
@Override
public String apply(@NonNull Integer integer) throws Exception {
return "This is result " + integer;
}
}).subscribe(new Consumer<String>() {
// RxJava 2.x 新增Consumer，可自定义实现，accept 里面相当于原本的onNext
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("accept : " + s +"\n");
Log.e(TAG, "accept : " + s +"\n" );
}
});
map 基本作用就是将一个 Observable 通过某种函数关系，转换为另一种 Observable，上面例子中就是把我们的 Integer 数据变成了 String 类型
###FlatMap
FlatMap将一个发送事件的上游Observable变换成多个发送事件的Observables， 然后将它们发射的时间合并后放进一个单独的Observable里，实现多个网络请求依次依赖
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("I am value " + integer);
}
int delayTime = (int) (1 + Math.random() * 10);
return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
}
}).subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.e(TAG, "flatMap : accept : " + s + "\n");
mRxOperatorsText.append("flatMap : accept : " + s + "\n");
}
});
它可以把一个发射器 Observable 通过某种方法转换为多个 Observables，然后再把这些分散的 Observables装进一个单一的发射器 Observable。但有个需要注意的是，flatMap 并不能保证事件的顺序，如果需要保证，需要用到我们下面要讲的 ConcatMap
###concatMap
concatMap作用和flatMap几乎一模一样，唯一的区别是它能保证事件的顺序,直接把 flatMap 替换为 concatMap 验证
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).concatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(@NonNull Integer integer) throws Exception {
List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("I am value " + integer);
}
int delayTime = (int) (1 + Math.random() * 10);
return Observable.fromIterable(list).delay(delayTime, TimeUnit.MILLISECONDS);
}
}).subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
Log.e(TAG, "concatMap : accept : " + s + "\n");
mRxOperatorsText.append("concatMap : accept : " + s + "\n");
}
});
/**
* ConcatMap（）
*/
// 采用RxJava基于事件流的链式操作
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
// 采用concatMap（）变换操作符
}).concatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final List<String> list = new ArrayList<>();
for (int i = 0; i < 3; i++) {
list.add("我是事件 " + integer + "拆分后的子事件" + i);
// 通过concatMap中将被观察者生产的事件序列先进行拆分，再将每个事件转换为一个新的发送三个String事件
// 最终合并，再发送给被观察者
}
return Observable.fromIterable(list);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.d(TAG, s);
}
});
concatDelayError（） / mergeDelayError（）
使用场景：在使用concat()和merge（）操作符时，如果其中一个Observable发出onError事件的时候，其他的Observable的事件就会被跳过，发送不出去。我们当然希望当其他observable的事件发送完成后再出发onError;
使用的时候：
/**
* @Describe 使用了concatDelayError（）的情况
*/
private void initErrorDelay() {
Observable.concatArrayDelayError(Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new NullPointerException());
// 发送Error事件，因为使用了concatDelayError，所以第2个Observable将会发送事件，等发送完毕后，再发送错误事件
emitter.onComplete();
}
}));
Observable.just(4,5,6)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
Log.d(TAG, "接收到了事件"+ integer );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
switchMap
只发送最近的一次数据，之前没有返回结果的数据直接放弃，用于搜索功能，避免老数据返回时和新数据覆盖问题
RxTextView.textChanges(this.mEditText)
.debounce(200,TimeUnit.MILLISECONDS)
.subscribeOn(AndroidSchedulers.mainThread())
.filter(new AppendOnlyLinkedArrayList.NonThrowingPredicate<CharSequence>() {
@Override
public boolean test(CharSequence charSequence) {
// 过滤数据
return charSequence.toString().trim().length()>0;
}
})
.switchMap(new Function<CharSequence, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(CharSequence charSequence) throws Exception {
// search 200毫秒内只搜索最近的一次输入，放弃其他没有返回结果的搜索操作
List<String> list = new ArrayList<String>();
list.add("abc");
list.add("ada");
// 模拟网络查询请求到的数据，并将数据发送出去
return Observable.just(list);
}
})
// .flatMap(new Function<CharSequence, ObservableSource<?>>() {
// @Override
// public ObservableSource<?> apply(CharSequence charSequence) throws Exception {
// // search
// List<String> list = new ArrayList<String>();
// list.add("abc");
// list.add("ada");
模拟网络查询请求到的数据，并将数据发送出去
// return Observable.just(list);
// }
// })
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) throws Exception {
// 展示搜索结果
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
}
});
delay
/**
* 延时操作符：
* @Author：yangtianfu
* @Date：{2018/12/14 20:01}
* @Description 延时800ms,用于等待异步操作完成
*/
Observable.just("delay")
.delay(800,TimeUnit.MILLISECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
// 在发送图片加载后延时0.8s设置listview滑动到底部
// mListViewMsgItems.setSelection(mListViewMsgItems.getBottom());
}
});
throttleFirst点击防止抖动
/**
* 点击防止抖动：
* @Author：yangtianfu
* @Date：{2018/12/14 20:01}
* @Description 控件防抖动，windowDuration时间内只允许点击一次
* 可以用多次初始化点击事件的方式，设置不同条件下控件的防抖动时间
* 讨论区开启时，1s内只能点击一次，讨论区关闭时，5s内只能点击一次
*/
RxView.clicks(bar_btn_text_live)
.throttleFirst(windowDuration,TimeUnit.SECONDS)
.subscribe(new Consumer<Object>() {
@Override
public void accept(Object o) throws Exception {
if (SPUtils.ReadInt(LiveActivity.this, "message", "message") == 100) {
PreLiveToast.getINSTANCE().initSinglePreLiveToast(LiveActivity.this,"管理员关闭了讨论区");
}else {
if (fl_emotionview_main.getVisibility()==View.GONE){
fl_emotionview_main.setVisibility(View.VISIBLE);
}
inputMsgDialog();
}
}
});
timer(过时)
在Rxjava中timer 操作符既可以延迟执行一段逻辑，也可以间隔执行一段逻辑
但在RxJava 2.x已经过时了，现在用interval操作符来间隔执行，timer和interval都默认执行在一个新线程上
mRxOperatorsText.append("timer start : " + TimeUtil.getNowStrTime() + "\n");
Log.e(TAG, "timer start : " + TimeUtil.getNowStrTime() + "\n");
Observable.timer(2, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Long>() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
mRxOperatorsText.append("timer :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
Log.e(TAG, "timer :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
}
});
interval
间隔执行操作，默认在新线程,实现心跳间隔任务,其接受三个参数，分别是第一次发送延迟，间隔时间，时间单位。
mRxOperatorsText.append("interval start : " + TimeUtil.getNowStrTime() + "\n");
mDisposable = Observable.interval(3, 2, TimeUnit.SECONDS)
// 延时3s开始执行，间隔事件2s
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread()) // 由于interval默认在新线程，所以我们应该切回主线程
.subscribe(new Consumer<Long>() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
mRxOperatorsText.append("interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
Log.e(TAG, "interval :" + aLong + " at " + TimeUtil.getNowStrTime() + "\n");
}
});
//当我们的Activity 都销毁的时候，实际上这个操作还依然在进行，所以，我们得花点小心思让我们在不需要它的时候干掉它
@Override protected void onDestroy() {
super.onDestroy();
mDisposable.dispose();
}
/**
* 网络轮询：
* @Author：yangtianfu
* @Date：{2018/12/14 20:01}
* @Description 延时0s,每隔10s请求一次
*/
Disposable disposable=Observable.interval(0,10, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Long>() {
@Override
public void accept(Long aLong) throws Exception {
presenter.getTecherInRoom(token,roomId);
}
});
defer
就是在每次订阅的时候就会创建一个新的 Observable
Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<Integer>>() {
@Override
public ObservableSource<Integer> call() throws Exception {
return Observable.just(1, 2, 3);
}
});
observable.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("defer : " + integer + "\n");
Log.e(TAG, "defer : " + integer + "\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("defer : onError : " + e.getMessage() + "\n");
Log.e(TAG, "defer : onError : " + e.getMessage() + "\n");
}
@Override
public void onComplete() {
mRxOperatorsText.append("defer : onComplete\n");
Log.e(TAG, "defer : onComplete\n");
}
});
reduce
就是一次用一个方法处理一个值，可以有一个seed作为初始值
Observable.just(1, 2, 3)
.reduce(new BiFunction<Integer, Integer, Integer>() {
//前两个Integer是参数，最后一个是求和返回值
@Override
public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("reduce : " + integer + "\n");
Log.e(TAG, "accept: reduce : " + integer + "\n");
}
});
中间采用 reduce ，支持一个 function 为两数值相加，所以应该最后的值是：1 + 2 = 3 + 3 = 6
scan
和上面的reduce差不多，区别在于reduce()只输出结果，而scan()会将过程中每一个结果输出
Observable.just(1, 2, 3)
.scan(new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(@NonNull Integer integer, @NonNull Integer integer2) throws Exception {
return integer + integer2;
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("scan " + integer + "\n");
Log.e(TAG, "accept: scan " + integer + "\n");
}
});
debounce
过滤掉发射速率过快的数据项
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Exception {
// send events with simulated time wait
emitter.onNext(1); // skip
Thread.sleep(400);
emitter.onNext(2); // deliver
Thread.sleep(505);
emitter.onNext(3); // skip
Thread.sleep(100);
emitter.onNext(4); // deliver
Thread.sleep(605);
emitter.onNext(5); // deliver
Thread.sleep(510);
emitter.onComplete();
}
}).debounce(500, TimeUnit.MILLISECONDS)
// 过滤掉不超过500ms的发射项
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("debounce :" + integer + "\n");
Log.e(TAG,"debounce :" + integer + "\n");
}
});
去除发送间隔时间小于 500 毫秒的发射事件，所以 1 和 3 被去掉了
###last
取出最后一个值，参数是没有值的时候的默认值
Observable.just(1, 2, 3)
.last(4)
.subscribe(new Consumer<Integer>() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
mRxOperatorsText.append("last : " + integer + "\n");
Log.e(TAG, "last : " + integer + "\n");
}
});
window
按照时间划分窗口，将数据发送给不同的Observable
Observable.interval(1, TimeUnit.SECONDS) // 间隔一秒发一次
.take(15) // 最多接收15个
.window(3, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Observable<Long>>() {
@Override
public void accept(@NonNull Observable<Long> longObservable) throws Exception {
mRxOperatorsText.append("Sub Divide begin...\n");
Log.e(TAG, "Sub Divide begin...\n");
longObservable.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Long>() {
@Override
public void accept(@NonNull Long aLong) throws Exception {
mRxOperatorsText.append("Next:" + aLong + "\n");
Log.e(TAG, "Next:" + aLong + "\n");
}
});
}
});
publishSubject
onNext() 会通知每个观察者，仅此而已
mRxOperatorsText.append("PublishSubject\n");
Log.e(TAG, "PublishSubject\n");
PublishSubject<Integer> publishSubject = PublishSubject.create();
publishSubject.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("First onSubscribe :"+d.isDisposed()+"\n");
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("First onNext value :"+integer + "\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("First onError:"+e.getMessage()+"\n");
}
@Override
public void onComplete() {
mRxOperatorsText.append("First onComplete!\n");
}
});
publishSubject.onNext(1);
publishSubject.onNext(2);
publishSubject.onNext(3);
publishSubject.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("Second onSubscribe :"+d.isDisposed()+"\n");
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("Second onNext value :"+integer + "\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("Second onError:"+e.getMessage()+"\n");
}
@Override
public void onComplete() {
mRxOperatorsText.append("Second onComplete!\n");
}
});
publishSubject.onNext(4);
publishSubject.onNext(5);
publishSubject.onComplete();
}
asyncSubject
在调用 onComplete() 之前，除了 subscribe() 其它的操作都会被缓存，在调用 onComplete() 之后只有最后一个 onNext() 会生效
AsyncSubject<Integer> asyncSubject = AsyncSubject.create();
asyncSubject.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("First onSubscribe :"+d.isDisposed()+"\n");
Log.e(TAG, "First onSubscribe :"+d.isDisposed()+"\n");
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("First onNext value :"+integer + "\n");
Log.e(TAG, "First onNext value :"+integer + "\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("First onError:"+e.getMessage()+"\n");
Log.e(TAG, "First onError:"+e.getMessage()+"\n" );
}
@Override
public void onComplete() {//在onNext之前调用了onComplete方法，直接执行最后一个onNext
mRxOperatorsText.append("First onComplete!\n");
Log.e(TAG, "First onComplete!\n");
}
});
asyncSubject.onNext(1);
asyncSubject.onNext(2);
asyncSubject.onNext(3);
asyncSubject.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("Second onSubscribe :"+d.isDisposed()+"\n");
Log.e(TAG, "Second onSubscribe :"+d.isDisposed()+"\n");
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("Second onNext value :"+integer + "\n");
Log.e(TAG, "Second onNext value :"+integer + "\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("Second onError:"+e.getMessage()+"\n");
Log.e(TAG, "Second onError:"+e.getMessage()+"\n" );
}
@Override
public void onComplete() {
mRxOperatorsText.append("Second onComplete!\n");
Log.e(TAG, "Second onComplete!\n");
}
});
asyncSubject.onNext(4);
asyncSubject.onNext(5);
asyncSubject.onComplete();
}
BehaviorSubject
BehaviorSubject 的最后一次 onNext() 操作会被缓存，然后在 subscribe() 后立刻推给新注册的 Observer
BehaviorSubject<Integer> behaviorSubject = BehaviorSubject.create();
behaviorSubject.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("First onSubscribe :"+d.isDisposed()+"\n");
Log.e(TAG, "First onSubscribe :"+d.isDisposed()+"\n");
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("First onNext value :"+integer + "\n");
Log.e(TAG, "First onNext value :"+integer + "\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("First onError:"+e.getMessage()+"\n");
Log.e(TAG, "First onError:"+e.getMessage()+"\n" );
}
@Override
public void onComplete() {
mRxOperatorsText.append("First onComplete!\n");
Log.e(TAG, "First onComplete!\n");
}
});
behaviorSubject.onNext(1);
behaviorSubject.onNext(2);
behaviorSubject.onNext(3);
behaviorSubject.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("Second onSubscribe :"+d.isDisposed()+"\n");
Log.e(TAG, "Second onSubscribe :"+d.isDisposed()+"\n");
}
@Override
public void onNext(@NonNull Integer integer) {
mRxOperatorsText.append("Second onNext value :"+integer + "\n");
Log.e(TAG, "Second onNext value :"+integer + "\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("Second onError:"+e.getMessage()+"\n");
Log.e(TAG, "Second onError:"+e.getMessage()+"\n" );
}
@Override
public void onComplete() {
mRxOperatorsText.append("Second onComplete!\n");
Log.e(TAG, "Second onComplete!\n");
}
});
behaviorSubject.onNext(4);
behaviorSubject.onNext(5);
behaviorSubject.onComplete();
Completable
只关心结果，也就是说 Completable 是没有 onNext 的，要么成功要么出错，不关心过程，在 subscribe 后的某个时间点返回结果
Completable.timer(1, TimeUnit.SECONDS)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new CompletableObserver() {
@Override
public void onSubscribe(@NonNull Disposable d) {
mRxOperatorsText.append("onSubscribe : d :" + d.isDisposed() + "\n");
Log.e(TAG, "onSubscribe : d :" + d.isDisposed() + "\n");
}
@Override
public void onComplete() {
mRxOperatorsText.append("onComplete\n");
Log.e(TAG, "onComplete\n");
}
@Override
public void onError(@NonNull Throwable e) {
mRxOperatorsText.append("onError :" + e.getMessage() + "\n");
Log.e(TAG, "onError :" + e.getMessage() + "\n");
}
});
zip
合并事件专用,分别从两个上游事件中各取出一个组合,一个事件只能被使用一次，顺序严格按照事件发送的顺序,最终下游事件收到的是和上游事件最少的数目相同,必须两两配对，多余的舍弃
实现多个接口数据共同更新 UI 在实际应用中，我们极有可能会在一个页面显示的数据来源于多个接口，这时候我们的 zip 操作符可以将多个 Observable 的数据结合为一个数据源再发射出去。
@Override
protected void doSomething() {
Observable.zip(getStringObservable(), getIntegerObservable(), new BiFunction<String, Integer, String>() {
@Override
public String apply(@NonNull String s, @NonNull Integer integer) throws Exception {
return s + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("zip : accept : " + s + "\n");
Log.e(TAG, "zip : accept : " + s + "\n");
}
});
}
private Observable<String> getStringObservable() {
return Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
if (!e.isDisposed()) {
e.onNext("A");
mRxOperatorsText.append("String emit : A \n");
Log.e(TAG, "String emit : A \n");
e.onNext("B");
mRxOperatorsText.append("String emit : B \n");
Log.e(TAG, "String emit : B \n");
e.onNext("C");
mRxOperatorsText.append("String emit : C \n");
Log.e(TAG, "String emit : C \n");
}
}
});
}
private Observable<Integer> getIntegerObservable() {
return Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
if (!e.isDisposed()) {
e.onNext(1);
mRxOperatorsText.append("Integer emit : 1 \n");
Log.e(TAG, "Integer emit : 1 \n");
e.onNext(2);
mRxOperatorsText.append("Integer emit : 2 \n");
Log.e(TAG, "Integer emit : 2 \n");
e.onNext(3);
mRxOperatorsText.append("Integer emit : 3 \n");
Log.e(TAG, "Integer emit : 3 \n");
e.onNext(4);
mRxOperatorsText.append("Integer emit : 4 \n");
Log.e(TAG, "Integer emit : 4 \n");
e.onNext(5);
mRxOperatorsText.append("Integer emit : 5 \n");
Log.e(TAG, "Integer emit : 5 \n");
}
}
});
zip 组合事件的过程就是分别从发射器 A 和发射器 B 各取出一个事件来组合，并且一个事件只能被使用一次，组合的顺序是严格按照事件发送的顺序来进行的，所以上面截图中，可以看到，
永远是和 A 结合的，永远是和 B 结合的。
最终接收器收到的事件数量是和发送器发送事件最少的那个发送器的发送事件数目相同，所以如截图中，5 很孤单，没有人愿意和它交往，孤独终老的单身
repeat
无条件地、重复发送 被观察者事件
具备重载方法，可设置重复创建次数
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) {
emitter.onNext(2);
emitter.onNext(3);
emitter.onError(new Exception("发生错误了"));
}
})
// .retry()
// 不传入参数 = 重复发送次数 = 无限次 repeat（）；
// 传入参数 = 重复发送次数有限 repeatWhen（Integer int ）；
// 1. 接收到.onCompleted()事件后，触发重新订阅 & 发送
// 2. 默认运行在一个新的线程上
.repeat(3)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
……
结合RxBing，通过combineLatest（）合并事件 & 联合判断
场景：当有多个元素需要同时判断后才能做出下一步动作的情况，比如，账号密码要同时输入，姓名和电话，工作等要同时输入的情况，这种做法就很nice，当然，除了RxJava，这里还要用到一个view的绑定机制RxBing
本文发稿时使用的RxBing版本如下：
implementation 'com.jakewharton.rxbinding2:rxbinding:2.1.1'
注意：
rxbinding默认已经包含了RxJava2的依赖，所以如果是后来引用的话，就可以直接用rxbinding替换RxJava的依赖，不要重复依赖！如下图所示：
/**
* @author： yangtianfu
* @time： 2018/9/5 16:10
* @more： https://blog.csdn.net/ytfunnysite
* @Describe 为每个EditText设置被观察者，用于发送监听事件
* 1. 此处采用了RxBinding：RxTextView.textChanges(name) = 对对控件数据变更进行监听（功能类似TextWatcher）
* 需要引入依赖：compile 'com.jakewharton.rxbinding2:rxbinding:2.0.0'
* 2. 传入EditText控件，点击任1个EditText撰写时，都会发送数据事件 = Function3（）的返回值（下面会详细说明）
* 3. 采用skip(1)原因：跳过 一开始EditText无任何输入时的空值
*/
private void initCombineLatest() {
Observable<CharSequence> nameObservable = RxTextView.textChanges(name).skip(1);
Observable<CharSequence> ageObservable = RxTextView.textChanges(age).skip(1);
Observable<CharSequence> jobObservable = RxTextView.textChanges(job).skip(1);
// 通过combineLatest（）合并事件 & 联合判断
Observable.combineLatest(nameObservable, ageObservable, jobObservable, new Function3<CharSequence, CharSequence, CharSequence, Boolean>() {
@Override
public Boolean apply(CharSequence charSequence, CharSequence charSequence2, CharSequence charSequence3) {
//规定表单信息输入不能为空
// 1. 姓名信息
boolean isUserNameValid = !TextUtils.isEmpty(name.getText());
// 除了设置为空，也可设置长度限制
// boolean isUserNameValid = !TextUtils.isEmpty(name.getText()) && (name.getText().toString().length() > 2 && name.getText().toString().length() < 9);
// 2. 年龄信息
boolean isUserAgeValid = !TextUtils.isEmpty(age.getText());
// 3. 职业信息
boolean isUserJobValid = !TextUtils.isEmpty(job.getText());
/* * 步骤5：返回信息 = 联合判断，即3个信息同时已填写，"提交按钮"才可点击 **/
return isUserNameValid && isUserAgeValid && isUserJobValid;
}
}).subscribe(new Consumer<Boolean>() {
@Override
public void accept(Boolean aBoolean) throws Exception {
/*
* 步骤6：返回结果 & 设置按钮可点击样式
**/
Log.e(TAG, "提交按钮是否可点击： "+aBoolean);
showToast("提交按钮是否可点击： "+aBoolean);
list.setEnabled(aBoolean);
}
});
}
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
