Repeat
重复发送事件
- 无限循环
- 循环次数
- 结束循环时间
- 结束循环条件
public final Observable repeat()
// 无限循环
public final Observable repeat(long times)
// 设置循环次数
public final Observable repeatUntil(BooleanSupplier stop)
// 设置循环结束条件
public final Observable repeatWhen(Function<? super Observable
示例
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(String 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:39) ___ "
- “apply() called with: integer = [”
- integer
- “], o = [”
- o
- “]”);
// 如果返回null则会抛出异常进入onError
return “吴彦祖”;
}
}).subscribe(new Observer() {
@Override public void onSubscribe(Disposable d) {
Log.i(“日志”, “(MainActivity.java:49) ___ onSubscribe”);
}
@Override public void onNext(String s) {
Log.d(“日志”, "(MainActivity.java:53) ___ " + “onNext() called with: s = [” + s + “]”);
}
@Override public void onError(Throwable e) {
Log.i(“日志”, “(MainActivity.java:57) ___ onError”);
}
@Override public void onComplete() {
Log.i(“日志”, “(MainActivity.java:61) ___ onComplete”);
}
});
FatMapCompletable
只能接受到onComplete回调
public final Completable flatMapCompletable(Function<? super T,? extends CompletableSource> mapper)
public final Completable flatMapCompletable(Function<? super T,? extends CompletableSource> mapper,
boolean delayErrors)
FlatMapMaybe
public final Observable flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper);
public final Observable flatMapMaybe(Function<? super T,? extends MaybeSource<? extends R>> mapper,
boolean delayErrors)
FlatMapSingle
单一接受者
public final Observable flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper)
public final Observable flatMapSingle(Function<? super T,? extends SingleSource<? extends R>> mapper,
boolean delayErrors)
ConcatMap
和FlatMap的区别是保证顺序发射(不存在交错顺序), 内部使用Concat实现;
例如: 两个异步的被观察者无论如何都会按照你参数添加的顺序发送事件
public final Flowable concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
public final Flowable concatMap(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch)
ConcatMapDelayError
延迟异常抛出到所有事件发送完毕后
public final Flowable concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper)
public final Flowable concatMapDelayError(Function<? super T,? extends org.reactivestreams.Publisher<? extends R>> mapper,
int prefetch,
boolean tillTheEnd)
ConcatMapEager
将所有被观察者的事件全部添加到一个被观察者上, 然后一次性发送;
public final Observable concatMapEager(Function<? super T,? extends ObservableSource<? extends R>> mapper)
事件变化
Map
将类型转换
public final Flowable map(Function<? super T,? extends R> mapper)
SwitchMap
每次源被观察者发送数据的时候都会向观察者发送一个新的被观察者, 但是如果有延迟操作就只会发送最后一个源被观察者创建的新被观察者;
在RxJava2之前SwitchMap叫做FlatMapLatest, 这样是否更加容易理解
public final Observable switchMap(Function<? super T,? extends ObservableSource<? extends R>> mapper)
示例
Observable.just(1, 2, 3)
.switchMap(new Function<Integer, ObservableSource<?>>() {
@Override
public ObservableSource apply(Integer integer) throws Exception {
return interval1;
}
})
.subscribe(ele -> Log.d(“日志”, "(MainActivity.java:39) ___ Result = " + ele));
截取事件
Buffer
创建一个List集合存储事件发送给观察者
- 数量
- 跨度
- 时间
public final Observable<java.util.List> buffer(int count) // 向List中添加事件数量
public final Observable<java.util.List> buffer(int count,
int skip) // 分段事件跨度
例如: {1.2.3.4.5} count = 3, skip = 2.
接收到的事件就为 {1,2,3} {3,4,5} {5}
public final Observable<java.util.List> buffer(java.util.concurrent.Callable<? extends ObservableSource> boundarySupplier)
// 在回调接口中boundarySupplier封装成集合Collection
// 缓存一定时间内的事件添加到集合中
public final Observable<java.util.List> buffer(long timespan,
long timeskip,
java.util.concurrent.TimeUnit unit)
Window
创建一个被观察者存储事件发送给观察者, 和Buffer的区别是返回的不是集合而是观察者, 该观察者包含跨度内的事件.
分时间
public final Observable<Observable> window(long timespan,
java.util.concurrent.TimeUnit unit)
// 按照时间跨度分组
public final Observable<Observable> window(long timespan,
java.util.concurrent.TimeUnit unit,
long count)
// 按照时间跨度内的数量分组 (规定事件内只能添加规定数量的事件到被观察者内)
public final Observable<Observable> window(long timespan,
long timeskip,
java.util.concurrent.TimeUnit unit)
// 按照时间跨度分组
public final Observable<Observable> window(long timespan,
java.util.concurrent.TimeUnit unit,
long count,
boolean restart)
分观察者发送
public final Observable<Observable> window(long count)
// 按照数量分组
public final Observable<Observable> window(long count,
long skip)
// 按照跨度分组
示例
Observable.just(1, 2, 3, 4).window(3).subscribe(new Consumer<Observable>() {
@Override public void accept(Observable integerObservable) throws Exception {
Log.i(“日志”, “(MainActivity.java:19) ___ 观察者”);
integerObservable.subscribe(new Consumer() {
@Override public void accept(Integer integer) throws Exception {
Log.i(“日志”, “(MainActivity.java:23) ___ 接受到事件”);
}
});
}
});
public final Observable<Observable> window(Callable<? extends ObservableSource> boundary)
// 参数观察者每次发送事件就会导致截取
public final <U,V> Observable<Observable> window(ObservableSource openingIndicator,
Function<? super U,? extends ObservableSource> closingIndicator)
public final <U,V> Observable<Observable> window(ObservableSource openingIndicator,
Function<? super U,? extends ObservableSource> closingIndicator,
int bufferSize)
// openingIndicator发送事件为开始截取, closingIndicator发送事件则停止截取, 一段一段的发送给观察者
GroupBy
根据key将Observable被观察者的事件分组变更为GroupedObservable, 该类继承自Observable, 但是新增一个方法
getKey()可以获取回调中返回对象key;
// 每次事件发送都会在参数回调中返回一个key, 如果key相等则会分成一组
public final Observable<GroupedObservable<K,T>> groupBy(Function<? super T,? extends K> keySelector)
// 分组然后再次发送事件
public final <K,V> Observable<GroupedObservable<K,V>> groupBy(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
ToList
将事件转成集合一次接受; 但是主要要求被观察者的事件类型统一
public final Single<java.util.List> toList()
public final Single<java.util.List> toList(int capacityHint)
// 集合初始化空间
public final <U extends java.util.Collection<? super T>> Single toList(java.util.concurrent.Callable collectionSupplier)
去除重复事件
Distinct
相同事件去重
public final Flowable distinct()
// 去除所有重复的事件
public final Observable distinct(Function<? super T,K> keySelector)
// 在回调内返回一个泛型值, 然后比较该泛型值来判断是否属于重复
public final Observable distinct(Function<? super T,K> keySelector,
java.util.concurrent.Callable<? extends java.util.Collection<? super K>> collectionSupplier)
示例:
/演示只取两个偶数/
Observable.just(1, 2, 3, 4, 5, 6).distinct(new Function<Integer, String>() {
/**
- 该方法每次发送事件都会回调
- @throws Exception
*/
@Override public String apply(Integer integer) throws Exception {
return integer % 2 == 0 ? “偶数” : “奇数”;
}
}).subscribe(new Consumer() {
@Override public void accept(Integer integer) throws Exception {
Log.d(“日志”,
"(MainActivity.java:34) ___ " + “accept() called with: integer = [” + integer + “]”);
}
});
DistinctUntilChanged
去除临近的重复事件
public final Flowable distinctUntilChanged()
// 只会去除邻近的重复事件
public final Observable distinctUntilChanged(BiPredicate<? super T,? super T> comparer)
// 该回调会每次返回邻近的两个事件, 然后你自己在回调内比较两个值是否算重复, 返回布尔类型
public final Observable distinctUntilChanged(Function<? super T,K> keySelector)
// 在回调内返回一个泛型值, 然后比较该泛型值来判断是否属于重复
示例:
Observable.just(1, 2, 2, 4, 5, 6).distinctUntilChanged(new BiPredicate<Integer, Integer>() {
@Override public boolean test(Integer integer, Integer integer2) throws Exception {
return integer.equals(integer2);
}
}).subscribe(new Consumer() {
@Override public void accept(Integer integer) throws Exception {
Log.d(“日志”,
"(MainActivity.java:34) ___ " + “accept() called with: integer = [” + integer + “]”);
}
});
只发送指定数据
Element
只发送指定位置(索引)的事件
public final Maybe elementAt(long index) // 索引
public final Single elementAt(long index,
T defaultItem) // 索引越界后发送事件
public final Maybe firstElement()
// 只发送第一个
public final Maybe lastElement()
public final Completable ignoreElements()
// 忽略全部事件
public final Single elementAtOrError(long index)
// 如果事件为空, 则会抛出异常
Debounce
发送事件后的一定时间内再次发送的事件都会被舍弃, 并且重新开始计时.
这个场景常用语搜索输入框的自动提示: 你连续输入文字会不断地发送事件,即会导致时间不断地被重置始终无法成功发送事件. 只有你在停止输入后才会成功发送事件.
public final Observable debounce(Function<? super T,? extends ObservableSource> debounceSelector)
public final Observable debounce(long timeout,
java.util.concurrent.TimeUnit unit)
同样还有一种实现方式
public final Observable throttleWithTimeout(long timeout,
public final Observable throttleWithTimeout(long timeout,
java.util.concurrent.TimeUnit unit,
Scheduler scheduler)
Filter
筛选事件,例如字符串为空则不发送事件
Observable.just(1, 20, 65, -5, 7, 19)
.filter(new Predicate() {
@Override
public boolean test(@NonNull Integer integer) throws Exception {
// 根据返回结果布尔类型确定是否拦截事件
return integer >= 10;
}
}).subscribe(new Consumer() {
@Override
public void accept(@NonNull Integer integer) throws Exception {
}
});
All
判断所有事件是否符合条件, 回调函数会执行多次但是观察者只能收到一个布尔类型值;
public final Single<java.lang.Boolean> all(Predicate<? super T> predicate)
Flowable.just(1, 2, 3, 4).all(new Predicate() {
@Override public boolean test(Integer integer) throws Exception {
return integer < 4;
}
}).subscribe(new Consumer() {
@Override public void accept(Boolean aBoolean) throws Exception {
}
});
First
只发射第一个事件, 如果没有发射事件直接onComplete()则会发射指定参数.
返回值为Single, 其被观察者不存在onComplete函数.
public final Single first(T defaultItem)
public final Single firstOrError()
// 如果仅onComplete会发射onError
Last
只发射最后一个事件, 如果没有发射事件直接onComplete()则会发射指定参数.
public final Single last(T defaultItem)
Amb
仅仅处理第一个发射事件的被观察者, 其他的观察者都会被抛弃.
要求添加的所有被观察者的事件类型需要统一;
public static Observable amb(java.lang.Iterable<? extends ObservableSource<? extends T>> sources)
// 集合类型
ambArray
和上面函数区别仅仅是参数变成可变参数
public static Observable ambArray(ObservableSource<? extends T>… sources)
// 可变参数类型
AmbWith
非静态函数, 结束对源被观察者的订阅, 然后对当前指定参数的被观察者订阅, 类似切换一个被观察者.
public final Observable ambWith(ObservableSource<? extends T> other)
Blocking
该操作符会打断RxJava的链式调用直接事件
只发送第一个或|最后一个事件
public final T blockingFirst()
public final T blockingFirst(T defaultItem)
public final T blockingLast()
public final T blockingLast(T defaultItem)
public final T blockingSingle()
- 如果没有设置默认值的话, 被观察者事件为空将抛出异常
- 使用single, 但是如果observable的事件不止一个, 将抛出异常
示例:
Long aLong = Observable.intervalRange(0, 5, 1, 1, TimeUnit.SECONDS)
.blockingFirst();
循环
public final void blockingForEach(Consumer<? super T> onNext)
public final java.lang.Iterable blockingIterable()
public final java.lang.Iterable blockingIterable(int bufferSize)
public final java.lang.Iterable blockingMostRecent(T initialValue)
public final void blockingSubscribe()
限制接受事件
- 指定时间内 第一个
- 指定时间内 最后一个
ThrottleFirst
只发送一定时间内的第一个事件, 默认在ComputationScheduler上执行, 但是可以指定Scheduler
public final Observable throttleFirst(long windowDuration,
java.util.concurrent.TimeUnit unit)
public final Observable throttleFirst(long skipDuration,
java.util.concurrent.TimeUnit unit,
Scheduler scheduler)
ThrottleLast
只发送一定时间内的最后一个事件
public final Observable throttleLast(long intervalDuration,
java.util.concurrent.TimeUnit unit)
public final Observable throttleLast(long intervalDuration,
java.util.concurrent.TimeUnit unit,
Scheduler scheduler)
ThrottleWithTimeout
发送事件A后将触发计时, 如果规定时间内有新的事件B发送, 将丢弃事件A; 功能和debounce 相同, 但是debounce可以添加一个Observable作为计时;
可以理解为只接受一定时间内的最后一个事件
public final Observable throttleWithTimeout(long timeout,
java.util.concurrent.TimeUnit unit)
public final Observable throttleWithTimeout(long timeout,
java.util.concurrent.TimeUnit unit,
Scheduler scheduler)
Sample
控制间隔, 在一定时间内只取最后发射的事件, 可以指定线程. 等同于throttleLast
public final Observable sample(long period,
java.util.concurrent.TimeUnit unit)
public final Observable sample(long period,
java.util.concurrent.TimeUnit unit,
boolean emitLast)
public final Observable sample(ObservableSource sampler)
public final Observable sample(ObservableSource sampler,
boolean emitLast)
TimeOut
public final Observable timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit)
public final Observable timeout(long timeout,
java.util.concurrent.TimeUnit timeUnit,
ObservableSource<? extends T> other)
- 设置一个超时的时间间隔, 如果发送事件的间隔超过这个事件就会发出一个异常事件TimeoutException(进入onError).
- 如果你不想发出的是异常而是发送一个新的被观察者事件, 就可以使用该方法
和上面的操作符不同的是, 这个操作符是通过回调函数返回的Observable来控制超时时间; 如果返回的Observable发送了事件但是源被观察者还未发送事件, 将判断为超时; 进入onError抛出TimeOutException
public final Observable timeout(Function<? super T,? extends ObservableSource> itemTimeoutIndicator)
public final Observable timeout(Function<? super T,? extends ObservableSource> itemTimeoutIndicator,
ObservableSource<? extends T> other)
以下重载可以给第一项被观察者发送的事件单独设置一个超时参数(Observable)
public final <U,V> Observable timeout(ObservableSource firstTimeoutIndicator,
Function<? super T,? extends ObservableSource> itemTimeoutIndicator)
public final <U,V> Observable timeout(ObservableSource firstTimeoutIndicator,
Function<? super T,? extends ObservableSource> itemTimeoutIndicator,
ObservableSource<? extends T> other)
跳过事件
- 数量
- 指定时间
- 倒序跳过
- 指定被观察者发送完毕
- 回调函数连续跳过
Skip
跳过事件
public final Observable skip(long count)
// 跳过指定数量的事件
public final Observable skip(long time,
java.util.concurrent.TimeUnit unit)
// 跳过指定时间内的事件
SkipLast
从后开始跳过发送事件;
public final Observable skipLast(int count)
public final Observable skipLast(long time,
java.util.concurrent.TimeUnit unit)
public final Flowable skipLast(long time,
java.util.concurrent.TimeUnit unit,
boolean delayError)
SkipUntil
在作为参数的被观察者没有发送完事件之前的所有源被观察者的事件都将被跳过;
public final Observable skipUntil(ObservableSource other)
示例代码:
Observable.intervalRange(0, 5, 1, 1, TimeUnit.SECONDS)
// 如果下面的被观察者的事件没有发送完毕(不包括onComplete)源被观察者的事件都将被跳过
.skipUntil(Observable.just(1)
.delay(2, TimeUnit.SECONDS))
.subscribe(new Consumer() {
@Override
public void accept(Long aLong) throws Exception {
Log.d(“日志”,
"(MainActivity.java:80) ___ " + “accept() called with: aLong = [” + aLong + “]”);
}
});
SkipWhile
在回调中判断是否抛弃事件;
和过滤操作符filter不同的是skipWhile只能从开头开始连续跳过事件, 即如果第一个事件你没有跳过, 那么该回调函数就不会再次执行, 也就是你之后都无法跳过事件了.
public final Observable skipWhile(Predicate<? super T> predicate)
停止订阅
- 可以接受的最多事件数量
- 可以接收到事件的时间
- 参数被观察者发送事件将停止源被观察者的订阅状态
- 倒序
- 回调函数判断是否停止
Take
该函数和Skip类似, 但是他是如果第一次阻止发射器继续发射事件, 就会直接进入onComplete回调
public final Observable take(long count)
// 控制最多接受到的事件数量
public final Observable take(long time,
java.util.concurrent.TimeUnit unit)
// 控制只有规定时间内才能接受到事件
TakeUntil
public final Observable takeUntil(ObservableSource other)
// 参数观察者发送事件就会导致源观察者被结束事件发送
public final Observable takeUntil(Predicate<? super T> stopPredicate)
// 通过回调来判断是否结束事件的发送, 返回true结束发射器发射事件
TakeLast
public final Observable takeLast(int count)
public final Observable takeLast(long count,
long time,
java.util.concurrent.TimeUnit unit)
public final Observable takeLast(long time,
java.util.concurrent.TimeUnit unit)
public final Observable takeLast(long time,
java.util.concurrent.TimeUnit unit,
boolean delayError)
TakeWhile
再回调中判断是否结束发射器(同样进入onComplete), 但是和TakeUntil不同的是返回false为结束.
public final Observable takeWhile(Predicate<? super T> predicate)
Join
添加一个被观察者(称为目标被观察者), 该被观察者发送的每个事件都将依次和源被观察者的所有事件结合(在同一个回调函数中传入)
public final <TRight,TLeftEnd,TRightEnd,R> Observable join(ObservableSource<? extends TRight> other,
Function<? super T,? extends ObservableSource> leftEnd,
Function<? super TRight,? extends ObservableSource> rightEnd,
BiFunction<? super T,? super TRight,? extends R> resultSelector)
示例代码:
Observable.just(1L, 2L, 3L, 4L)
.join(Observable.just(5L, 6L, 7L, 8L), new Function<Long, ObservableSource>() {
/**
- 接受源被观察者事件
- @param aLong
- @return 返回的被观察者发送事件后将终止源被观察者的事件发送
- @throws Exception
*/
@Override
public ObservableSource apply(Long aLong) throws Exception {
Log.d(“日志”,
"(MainActivity.java:65) ___ " + “源被观察者 aLong = [” + aLong + “]”);
return Observable.interval(3, TimeUnit.SECONDS);
}
}, new Function<Long, ObservableSource>() {
/**
- 接受添加的被观察者事件(join Observable)
- @param aLong
- @return 返回的被观察者发送事件后就将终止添加的被观察者的
- @throws Exception
/
@Override
public ObservableSource apply(Long aLong) throws Exception {
Log.d(“日志”,
"(MainActivity.java:75) ___ " + “被添加的被观察者 aLong = [” + aLong + “]”);
return Observable.interval(3, TimeUnit.SECONDS);
}
}, new BiFunction<Long, Long, String>() {
/* - 同时接受被添加的被观察者和源被观察者的事件
- @param aLong 源被观察者发送的事件
- @param aLong2 被添加的被观察者发送的事件
- @return 该返回值最终被观察者接收到
- @throws Exception
*/
@Override
public String apply(Long aLong, Long aLong2) throws Exception {
Log.d(“日志”, "(MainActivity.java:89) ___ " + “apply() called with: aLong = [” + aLong
- “], aLong2 = [” + aLong2 + “]”);
return aLong + “” + aLong2;
}
})
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.d(“日志”, "(MainActivity.java:83) ___ " + “accept() called with: s = [” + s + “]”);
}
});
GroupJoin
和Join类似
public final <TRight,TLeftEnd,TRightEnd,R> Observable groupJoin(ObservableSource<? extends TRight> other,
Function<? super T,? extends ObservableSource> leftEnd,
Function<? super TRight,? extends ObservableSource> rightEnd,
BiFunction<? super T,? super Observable,? extends R> resultSelector)
示例:
Observable.just(1L, 2L, 3L, 4L)
.groupJoin(Observable.just(5L, 6L, 7L, 8L),
new Function<Long, ObservableSource>() {
@Override
public ObservableSource apply(Long aLong) throws Exception {
return null;
}
}, new Function<Long, ObservableSource>() {
@Override
public ObservableSource apply(Long aLong) throws Exception {
return null;
}
}, new BiFunction<Long, Observable, String>() {
@Override
public String apply(Long aLong, Observable longObservable) throws Exception {
return null;
}
})
.subscribe(new Consumer() {
@Override
public void accept(String s) throws Exception {
Log.d(“日志”, "(MainActivity.java:78) ___ " + “accept() called with: s = [” + s + “]”);
}
});
ToMap
public final Single<java.util.Map<K,T>> toMap(Function<? super T,? extends K> keySelector)
public final <K,V> Single<java.util.Map<K,V>> toMap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector)
public final <K,V> Single<java.util.Map<K,V>> toMap(Function<? super T,? extends K> keySelector,
Function<? super T,? extends V> valueSelector,
java.util.concurrent.Callable<? extends java.util.Map<K,V>> mapSupplier)
错误处理
onErrorResumeNext
如果发生异常将接收到一个回调返回另一个被观察者(执行OnNext不执行onError)
// 订阅另一个被观察者
public final Observable onErrorResumeNext(ObservableSource<? extends T> next)
onErrorReturn
如果发生异常将接收到一个回调返回事件(执行OnNext不执行onError)
public final Observable onErrorReturn(Function<? super java.lang.Throwable,? extends T> valueSupplier)
两个操作符最后都会执行onComplete
Retry
当被观察者的发射器发出异常事件(onError)以后会执行重试操作
public final Observable retry()
// 当发生错误将重新发送事件(被观察者的所有事件全部重新发送)
public final Observable retry(long times)
// 重新发送的次数
public final Observable retry(Predicate<? super java.lang.Throwable> predicate)
public final Observable retry(BiPredicate<? super java.lang.Integer,? super java.lang.Throwable> predicate)
// 在回调函数中判断是否重试(和上面的操作符不同的是该回调函数里面会有一个重试次数的参数)
public final Observable retry(long times, Predicate<? super java.lang.Throwable> predicate)
// 判断函数 + 重试次数
RetryUntil
该操作符其实Retry已经有相同实现retry(predicate)
不同的是返回true表示停止重试
public final Observable retryUntil(BooleanSupplier stop)
RetryWhen
在回调函数中返回一个被观察者, 该被观察者如果发出错误事件就会导致源被观察者重试. 如果没有发出错误事件就不会触发重试;
public final Observable retryWhen(Function<? super Observable
示例:
该示例不会触发重试;
Observable.create(
new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onError(null);
emitter.onNext(3);
}
})
.retryWhen(new Function<Observable, ObservableSource<?>>() { @Override public ObservableSource<?> apply(Observable throwableObservable) throws Exception {
return Observable.just(23);
}
})
.subscribe(
new DefaultObserver() {
@Override
public void onNext(Integer integer) {
System.out.println(“integer = [” + integer + “]”);
}
@Override
public void onError(Throwable e) {
System.out.println(“Main.onError”);
}
@Override
public void onComplete() {
System.out.println(“Main.onComplete”);
}
});
判断操作
Contains
判断发射的事件是否包含指定的事件, 观察者得到一个布尔类型的值
public final Single<java.lang.Boolean> contains(java.lang.Object element)
Any
public final Single<java.lang.Boolean> any(Predicate<? super T> predicate)
依次判断每个事件, 如果返回true则马上终止发射器
Observable.just(1, 2, 3, 4).any(new Predicate() {
@Override public boolean test(Integer integer) throws Exception {
Log.d(“日志”,
"(MainActivity.java:27) ___ " + “test() called with: integer = [” + integer + “]”);
if (integer == 3) {
return true;
} else {
return false;
}
}
}).subscribe(new Consumer() {
@Override public void accept(Boolean aBoolean) throws Exception {
Log.d(“日志”,
"(MainActivity.java:33) ___ " + “accept() called with: aBoolean = [” + aBoolean + “]”);
}
});
IsEmpty
public final Single<java.lang.Boolean> isEmpty()
判断是否有发射过事件, 观察者得到个布尔类型的值.
DefaultIfEmpty
public final Observable defaultIfEmpty(T defaultItem)
如果发射器没有发射任何事件, 就会发射一个指定的默认事件, 例如发射器的事件被拦截
SwitchIfEmpty
public final Observable switchIfEmpty(ObservableSource<? extends T> other)
如果没有发射事件就用另一个被观察者替代
Flowable.empty()
.switchIfEmpty(Flowable.just(3, 4, 5))
.subscribe(ele -> Log.i(“tag”, String.valueOf(ele)));
SequenceEqual
public static Single<java.lang.Boolean> sequenceEqual(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2,
BiPredicate<? super T,? super T> isEqual)
// 最后的
public static Single<java.lang.Boolean> sequenceEqual(ObservableSource<? extends T> source1,
ObservableSource<? extends T> source2)
会比较两个被观察者是否相同, 然后观察者接受一个布尔类型的值, 发射的事件数量不相同, 类型不相同都会为false. 只要判断到不相同马上就会终止事件的发送.
Observable.sequenceEqual(Observable.intervalRange(0, 3, 0, 1, TimeUnit.SECONDS),
Observable.just(0l, 1l, 2l), new BiPredicate<Long, Long>() {
@Override public boolean test(Long aLong, Long aLong2) throws Exception {
// 在这里判断是否相等
return false;
}
}).subscribe(new Consumer() {
@Override public void accept(Boolean aBoolean) throws Exception {
// 最终结果
}
});
合并操作
Reduce
相加操作符, 每次都可以两个事件一起处理, 然后所有事件都被处理后就会被观察者接受到最终的事件
public final Maybe reduce(BiFunction<T,T,T> reducer)
第一次处理(apply)会接收到事件1和事件2, 然后第N次就是上次处理的结果(apply的返回值)和事件N
示例:
Observable.just(1, 2, 3, 4).reduce(new BiFunction<Integer, Integer, Integer>() {
/**
- 该方法会回调多次直到所有事件都依次相加(或者说操作)以后才会被观察者接收到最终的结果
- @throws Exception
*/
@Override public Integer apply(Integer integer, Integer integer2) throws Exception {
// 三个泛型分别对应 上次运行结果 当前事件 返回值
return integer + integer2;
}
}).subscribe(new Consumer() {
@Override public void accept(Integer integer) throws Exception {
}
});
待定操作符
public final Single reduce(R seed,
BiFunction<R,? super T,R> reducer)
public final Single reduceWith(java.util.concurrent.Callable seedSupplier,
BiFunction<R,? super T,R> reducer)
Scan
和Reduce类似, 但是每次观察者都能收到回调参数的返回值结果作为事件
public final Observable scan(BiFunction<T,T,T> accumulator)
public final Observable scan(R initialValue, // 加入一个初始化的值
BiFunction<R,? super T,R> accumulator)
ScanWith
public final Observable scanWith(java.util.concurrent.Callable seedSupplier,
BiFunction<R,? super T,R> accumulator)
Collect
可以创建容器来依次操作数据(观察者只会收到一次事件, 也就是容器)
Flowable.just(1, 2, 3)
.collect(
new Callable<ArrayList>() {//创建收集容器
@Override
public ArrayList call() throws Exception {
return new ArrayList<>();
}
}, new BiConsumer<ArrayList, Integer>() {//创建收集
@Override
public void accept(ArrayList list, Integer integer)
throws Exception {//前者容器，后者数据
list.add(integer);
}
})
.subscribe(ele -> Log.d(“日志”, "(MainActivity.java:33) ___ Result = " + String.valueOf(ele)));
时间
Delay
delay操作符会延迟每个事件发送的时间(包括onComplete但不包括onError)
public final Observable delay(long delay,
TimeUnit unit)
public final Observable delay(Function<? super T,? extends ObservableSource> itemDelay)
// 回调参数如果发送onNext就会导致延迟结束
TimeStamp
该操作符将事件和发送的时间都封装到一个对象Timed中
public final Observable<Timed> timestamp()
public final Observable<Timed> timestamp(Scheduler scheduler)
public final Observable<Timed> timestamp(TimeUnit unit)
public final Observable<Timed> timestamp(TimeUnit unit,
Scheduler scheduler)
示例:
Observable.intervalRange(0, 5, 2, 2, TimeUnit.SECONDS)
.timestamp()
.subscribe(new Consumer<Timed>() {
@Override
public void accept(Timed longTimed) throws Exception {
Log.d(“日志”,“accept() called with: longTimed = [” + longTimed + “]”);
}
});
结果
longTimed = [Timed[time=1525735346216, unit=MILLISECONDS, value=2]]
Count
观察者将接收到事件数量, 而无法收到事件本身.
Flowable.just(1,2,3,4,5).count().subscribe(new BiConsumer<Long, Throwable>() {
@Override public void accept(Long aLong, Throwable throwable) throws Exception {
Log.d(“日志”, "(MainActivity.java:18) ___ Result = " + aLong);
}
});
BackPressure
意为"背压"
了解了Observable和Flowable的区别，我们还不知什么叫做背压，下面我们来简单了解下概念。所谓背压就是生产者（被观察者）的生产速度大于消费者（观察者）消费速度从而导致的问题。
举一个简单点的例子，如果被观察者快速发送消息，但是观察者处理消息的很缓慢，如果没有特定的流（Flow）控制，就会导致大量消息积压占用系统资源，最终导致十分缓慢。
同步线程是不可能产生这种问题, 观察者没有处理完事件就不可能再次发送事件.
怎么优化和减少这种情况后面再探讨，不过可以注意到，Flowable创建的时候已经设置了BackpressureStrategy，而且Subscriber使用了request来控制最大的流量。
被观察者
Hot Observable
热观察者: 没有订阅就开始发送事件, 订阅只会受到订阅之后发送的事件.
重放
- 线程
- 时间
- 时间单位
- 缓存大小
public final ConnectableObservable replay()
ConnectableObservable
ConnectableObservable只有在使用函数connect以后才会让观察者收到事件
public final Disposable connect()
public abstract void connect(Consumer<? super Disposable> connection)
自动连接, 但是不会在所有观察者取消订阅时断开上游事件
public Observable autoConnect()
public Observable autoConnect(int numberOfSubscribers) // 当N个观察者订阅时自动connect
public Observable autoConnect(int numberOfSubscribers,
Consumer<? super Disposable> connection) // 该回调中可以得到Dispose对象用于取消上游
该函数会在第一个观察者订阅时connect, 在所有观察者取消订阅时结束上游事件发送.
public Observable refCount()
public final Observable share() // 等同于publish和refCount
Observable
不支持背压的被观察者, 性能高
ObservableSource
Flowable
支持背压的被观察者, 性能略比Observable低, 函数体系和Observable有所区别.
Publisher
Publisher该类属于Flowable的根接口, ObservableSource属于Observable的根接口;
Single
该被观察者只能发出一个事件, 重复发送不会受到(因为只能发送一条事件所以不存在背压).
Single.create(object : SingleOnSubscribe {
override fun subscribe(emitter: SingleEmitter) {
emitter.onSuccess(12)
}
}).subscribe(object : SingleObserver<Int?> {
override fun onSuccess(t: Int) {
}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
最后
题外话，我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。
我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在IT学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多程序员朋友无法获得正确的资料得到学习提升，故此将并将重要的Android进阶资料包括自定义view、性能优化、MVC与MVP与MVVM三大框架的区别、NDK技术、阿里面试题精编汇总、常见源码分析等学习资料。
【Android思维脑图（技能树）】
知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。
【Android进阶学习视频】、【全套Android面试秘籍】
希望我能够用我的力量帮助更多迷茫、困惑的朋友们，帮助大家在IT道路上学习和发展
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
不会受到(因为只能发送一条事件所以不存在背压).
Single.create(object : SingleOnSubscribe {
override fun subscribe(emitter: SingleEmitter) {
emitter.onSuccess(12)
}
}).subscribe(object : SingleObserver<Int?> {
override fun onSuccess(t: Int) {
}
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-qWCF8Ypg-1713516867149)]
[外链图片转存中…(img-4oeviMfl-1713516867151)]
[外链图片转存中…(img-vO07IU7A-1713516867152)]
[外链图片转存中…(img-Ypj75bBc-1713516867153)]
[外链图片转存中…(img-YcJUc5yl-1713516867153)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）
最后
题外话，我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。
我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在IT学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多程序员朋友无法获得正确的资料得到学习提升，故此将并将重要的Android进阶资料包括自定义view、性能优化、MVC与MVP与MVVM三大框架的区别、NDK技术、阿里面试题精编汇总、常见源码分析等学习资料。
【Android思维脑图（技能树）】
知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。
[外链图片转存中…(img-0VJ9uOua-1713516867154)]
【Android进阶学习视频】、【全套Android面试秘籍】
希望我能够用我的力量帮助更多迷茫、困惑的朋友们，帮助大家在IT道路上学习和发展
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
