这篇章主要介绍Rxjava的辅助操作符
目录
Delay
延迟一段指定的时间再发射来自Observable的发射物
Observable.just(1,2,3).delay(2000, TimeUnit.MILLISECONDS, Schedulers.trampoline()).subscribe(num -> System.out.println(num+""));
结果：
1
2
3
上面的结果是延迟两秒发射，注意是每个数据都延迟了两秒发射。
一参为延迟的时间，二参为时间单位，三参为调度器表示在哪个线程调度。
Do
这系列操作符有好几个，我只写一个，后面都很容易明白了。
Observable.just(1,2,3)
.doOnNext(num ->System.out.println(num+"++"))
.subscribe(num -> System.out.println(num+"*"));
结果：
1++
1*
2++
2*
3++
3*
看上面的结果，一分析就明白了。doOnNext就是在onNext输出前，执行你写的操作。下面还有do的其他操作符
doOnSubscribe ：订阅前调用
doOnUnsubscribe：不订阅前调用
doOnCompleted ：完成前调用
doOnError：异常终止前调用
doOnTerminate：终止前调用，不管completed还是error
finallyDo： 终止后调用，不管completed还是error
Serialize
一个Observable可以异步调用它的观察者的方法，可能是从不同的线程调用。这可能会让Observable行为不正确，它可能会在某一个onNext调用之前尝试调用onCompleted或onError方法，或者从两个不同的线程同时调用onNext方法。
这个暂时不写例子，以后补上。看到这里的朋友，也可以自己试一下写demo，我也渴望参详参详。
TimeInterval
TimeInterval操作符拦截原始Observable发射的数据项，替换为发射表示相邻发射物时间间隔的对象。
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
for (int i = 0; i < 3; i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
observableEmitter.onNext(i+"");
}
observableEmitter.onComplete();
}
}).timeInterval(Schedulers.trampoline())
.subscribe(new Consumer<Timed<String>>() {
@Override
public void accept(Timed<String> stringTimed) throws Throwable {
System.out.println(stringTimed.value() +"::" +stringTimed.time());
}
});
结果：
0::1005
1::1000
2::1009
timeInterval操作符，可以让我们发射的数据转换成Timed<?>类，这个对象的value()为我们发射的数据的值，time()为上一个数据和这个数据发射间的时间间隔（单位：毫秒），而第一项数据得到的时间为订阅到第一个发射的时间间隔。
Timeout
对原始Observable的一个镜像，如果过了一个指定的时长仍没有发射数据，它会发一个错误通知
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> observableEmitter) throws Exception {
observableEmitter.onNext(1);
Thread.sleep(1000);
observableEmitter.onNext(2);
Thread.sleep(1000);
observableEmitter.onNext(3);
Thread.sleep(3000);
observableEmitter.onNext(4);
}
}).timeout(2000, TimeUnit.MILLISECONDS).subscribe(num -> System.out.println(num+"*"), throwable -> {System.out.println(throwable.getMessage());});
结果：
1*
2*
3*
The source did not signal an event for 2000 milliseconds and has been terminated.
timeout设置一个超时时间，当两个发射时间的间隔大于设定时间时，就会抛出异常。
Timestamp
给Observable发射的数据项附加一个时间戳
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
for (int i = 0; i < 3; i++){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
observableEmitter.onNext(i+"");
}
observableEmitter.onComplete();
}
}).timestamp(Schedulers.trampoline())
.subscribe(new Consumer<Timed<String>>() {
@Override
public void accept(Timed<String> stringTimed) throws Throwable {
System.out.println(stringTimed.value() +"::" +stringTimed.time());
}
});
结果：
0::1573968123248
1::1573968124248
2::1573968125257
与TimeInterval有点相似，不过TimeInterval让发射数据带有时间间隔。而Timestamp让我们发射的数据带有发射时的时间戳。
To
将Observable转换为另一个对象或数据结构
Observable.just(1, 2, 3, 4).toList().subscribe(new Consumer<List<Integer>>() {
@Override
public void accept(List<Integer> integers) throws Throwable {
System.out.println(integers.get(3)+"++");
}
});
结果：
4++
toList就是把我们发射的数据弄成一个列表然后给到观察者。
Observable.just(1, 2, 3, 4).toMap(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Throwable {
return integer+"";
}
}).subscribe(new Consumer<Map<String, Integer>>() {
@Override
public void accept(Map<String, Integer> map) throws Throwable {
System.out.println(map.get("2")+"*");
}
});
结果：
2*
toMap就是把发射数据弄成一个map对象发射给订阅者。而toMap里面放的函数就是决定map的key。
Using
创建一个只在Observable生命周期内存在的一次性资源。这是官方说法，我只会按我自己理解说
Observable.using(new Supplier<Student>() {
@Override
public Student get() throws Throwable {
Student student = new Student("aaa");
return student;
}
}, new Function<Student, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Student student) throws Throwable {
return Observable.just(student.getName());
}
}, new Consumer<Student>() {
@Override
public void accept(Student student) throws Throwable {
System.out.println(student.getName()+"++");
}
}).subscribe(str -> System.out.println(str+"*"));
结果：
aaa*
aaa++
using函数里面的参数，一参为返回这次要回收的资源，二参为把这个资源转换为observable，然后由这个observable来订阅我们的观察者，三参为数据处理完毕后，资源进入的函数，你就可以对这个资源进行回收或其他处理。
上面代码，我们创了一个名为aaa的学生对象，然后第二参数我们返回一个以学生名字的String的observable。先进入onNext订阅的逻辑输出了aaa*，然后再到第三参数函数的处理。
