全面学习RxJava_RxAndroid_AutoDispose_RxBinding_RxBus

// 设置单位为秒
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(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&