Rxjava辅助操作符

Rxjava操作符索引

这篇章主要介绍Rxjava的辅助操作符

目录

Delay

Do

Serialize

TimeInterval

Timeout

Timestamp

To

Using

---

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*，然后再到第三参数函数的处理。