java.util.concurrent.TimeUnit unit) // 时间单位
TimerInterval
记录轮循器的信息
- 时间间隔
- 时间单位
- 值
- 指定线程
public final Observable<Timed> timeInterval()
// 时间间隔设置固定单位
public final Observable<Timed> timeInterval(TimeUnit unit)
输出示例:
// 无参默认单位为毫秒
Timed[time=1003, unit=MILLISECONDS, value=12]
// 设置单位为秒
Timed[time=1, unit=SECONDS, value=40]
Range
观察者收到范围内数字, 没有默认在特定的线程执行.
- 开始数字
- 数字范围
// 发送int事件类型
public static Observable<java.lang.Integer> range(int start, // 开始
int count) // 结束
// 发送long的事件类型
public static Observable<java.lang.Long> rangeLong(long start,
long count)
Repeat
重复发送事件
- 无限循环
- 循环次数
- 结束循环时间
- 结束循环条件
public final Observable repeat()
// 无限循环
public final Observable repeat(long times)
// 设置循环次数
public final Observable repeatUntil(BooleanSupplier stop)
// 设置循环结束条件
public final Observable repeatWhen(Function<? super Observable<java.lang.Object>,
? extends ObservableSource<?>> handler)
// 添加一个被观察者作为重新发送事件的条件
示例
io.reactivex.Observable.just(1)
.repeatUntil(
new BooleanSupplier() {
/**
- @return 返回true表示结束循环
- @throws Exception
*/
@Override
public boolean getAsBoolean() throws Exception {
return true;
}
})
.subscribe(System.out::println);
RepeatWhen
如果回调函数中的被观察者发送onComplete和onError事件不会进入重复事件
但是如果发送onNext事件就会导致重复发送
Observable.intervalRange(0, 5, 1, 1, TimeUnit.SECONDS, TrampolineScheduler.instance())
.repeatWhen(
new Function<Observable, ObservableSource<?>>() {
@Override
public ObservableSource<?> apply(Observable objectObservable)
throws Exception {
// 源被观察者结束后(onComplete)等待五秒再次重新发送
return Observable.interval(5, TimeUnit.SECONDS);
}
})
.subscribe(
new Consumer() {
@Override
public void accept(Long aLong) throws Exception {
// do something
}
});
多观察者创建
Concat
将多个被观察者连接起来按照顺序发送
ConcatArray
和Concat
操作符其实都一样, 只不过可以接受数组而已
Merge
将多个被观察者合并, 遵守时间顺序(不遵守参数添加顺序)
public static Observable mergeArray(int maxConcurrency,
int bufferSize,
ObservableSource<? extends T>… sources)
Zip
可以将多个发射器发送的事件对应发送顺序组合成一个然后统一一次接收事件, 遵守两两合并的原则.
如果存在异步情况, 将会等待需要合并的两个事件同时执行完毕后再发送给观察者;
- 遵守订阅顺序
public static <T,R> Observable zip(ObservableSource<? extends ObservableSource<? extends T>> sources,
Function<? super java.lang.Object[],? extends R> zipper)
示例:
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() {
@Override public void accept(@NonNull String s) throws Exception {
// 这里只会接受到apply的返回值
}
});
ZipWith
将传入的被观察者和源被观察者对应组合(Zip)该方法属于非静态方法
Observable.just(1).zipWith(Observable.just(2), new BiFunction<Integer, Integer, String>() {
@Override
public String apply(Integer integer, Integer integer2) throws Exception {
System.out.println(“integer = [” + integer + “], integer2 = [” + integer2 + “]”);
return integer + “” + integer2;
}
}).subscribe(new Consumer() {
@Override
public void accept(Strin
g s) throws Exception {
// 结果: s = [12]
System.out.println(“s = [” + s + “]”);
}
});
CombineLast
最后一个被观察者的所有事件依次前面的所有被观察者的最后事件依次合并, 然后观察者依次收到合并后的事件
- 遵守订阅观察者顺序
public static <T1,T2,T3,R> Observable combineLatest(ObservableSource<? extends T1> source1,
ObservableSource<? extends T2> source2,
Function3<? super T1,? super T2,? super T3,? extends R> combiner)
示例结果:
最后一个被观察者和之前的所有的被观察者的最后一个事件同时被接收到
s = [轮循器一10轮循器二10轮循器三1]
s = [轮循器一10轮循器二10轮循器三2]
s = [轮循器一10轮循器二10轮循器三3]
s = [轮循器一10轮循器二10轮循器三4]
s = [轮循器一10轮循器二10轮循器三5]
s = [轮循器一10轮循器二10轮循器三6]
s = [轮循器一10轮循器二10轮循器三7]
s = [轮循器一10轮循器二10轮循器三8]
s = [轮循器一10轮循器二10轮循器三9]
s = [轮循器一10轮循器二10轮循器三10]
该函数属于第一个被观察者的所有事件依次和后面的所有被观察者的最新事件合并发送给观察者
public final Observable withLatestFrom(ObservableSource<?>[] others,
Function<? super java.lang.Object[],R> combiner)
变化操作符
FlatMap
将事件拦截然后转成被观察者再次发送
交错顺序, 即发射器发送事件的时候可能是异步或者延迟的.
public final Observable flatMap(Function<? super T,? extends ObservableSource<? extends R>> mapper)
// onNext/onError/onComplete 分别回调
public final Observable flatMap(Function<? super T,? extends ObservableSource<? extends R>> onNextMapper,
Function<? super java.lang.Throwable,? extends ObservableSource<? extends R>> onErrorMapper,
java.util.concurrent.Callable<? extends ObservableSource<? extends R>> onCompleteSupplier)
public final <U,R> Observable flatMap(Function<? super T,? extends ObservableSource<? extends U>> mapper,
BiFunction<? super T,? super U,? extends R> resultSelector)
FlatMapIterable
public final Observable flatMapIterable(Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
// 就是转成集合类型被观察者接收到
重载方法将可迭代对象最终又转换成单个对象
public final <U,V> Observable flatMapIterable(
Function<? super T,? extends java.lang.Iterable<? extends U>> mapper,
BiFunction<? super T,? super U,? extends V> resultSelector)
示例
Observable.just(1, 2, 3, 4, 5).flatMapIterable(new Function<Integer, Iterable>() {
@Override public Iterable apply(Integer integer) throws Exception {
Log.d(“日志”,
"(MainActivity.java:32) ___ " + “apply() called with: integer = [” + integer + “]”);
// iterable属于所有集合的根接口
ArrayList strings = new ArrayList<>();
strings.add(integer.toString() + “集合中”);
return strings;
}
}, new BiFunction<Integer, Object, String>() {
/**
- 得到一个最终被观察者接受的事件
- @param t1 发射器的事件
- @param t2 被添加到集合中对象
- @return 最终被观察者接受的事件
- @throws Exception 如果返回null将抛出异常
*/
@Override public String apply(Integer integer, Object o) throws Exception {
Log.d(“日志”, "(MainActivity.java:3