【从零学 RxJava】RxJava 2 —— 创建操作符

前言

操作符是 RxJava 的重要组成部分，本章节解读 创建操作符

版本

3.0.4

create

从头创建一个 Observable，一个形式正确的有限 Observable 必须尝试调用 观察者 的 onComplete 或 onError 一次，而且此后不再调用 观察者 的任何其他方法

demo

	static void create() {
        Observable.create(e -> {
            // 检查观察者的订阅状态
            if (!e.isDisposed()) {
                IntStream.rangeClosed(0, 10)
                        .forEach(i -> e.onNext(i));
                e.onComplete();
            }
        }).subscribe(t -> System.out.println(t));
    }

	// 1 到 10

just

发射指定值的 Observable，可以接受 1-10 个参数

demo

	static void just() {
        Observable.just(1, 2).subscribe(t -> System.out.println(t));
    }

	// 1 2

from

在 RxJava 中，from 操作符可以将 Future、Iterable 和 数组 转换成 Observable，对于 Iterable 和 数组，产生的 Observable 会发射每一项数据

demo

	static void from() {
        Observable.fromArray("1", "2").subscribe(t -> System.out.println(t));
        // "1" "2"

        Observable.fromIterable(
                new ArrayList<Integer>() {
                    {
                        add(1);
                        add(2);
                    }
                }
        ).subscribe(t -> System.out.println(t));
		// 1 2
    }

fromFuture

对于 Future，他会发射 Future.get() 方法返回的单个数据，同时 fromFuture 还有重载方法，支持指定超时，对于超时的 Future，会发射错误通知并终止

demo

	static void fromFuture() {
        FutureTask future = new FutureTask(() -> {
            TimeUnit.SECONDS.sleep(3);
            return "done";
        });
        new Thread(future).start();

        // 2s 超时
        Observable.fromFuture(future, 2, TimeUnit.SECONDS)
                .subscribe(t -> System.out.println(t));
    }

示例中设置 超时时间 为 2s，因此会发射一个错误消息

defer

直到有 观察者 订阅才创建 Observable，并且为每个观察者创建一个全新的 Observable

demo

	static void defer() {
        Observable.defer(() -> {
            return Observable.just("test");
        }).subscribe(t -> System.out.println(t));
    }
    // test

interval

创建一个按固定时间间隔发射整数序列的 Observable

demo

	static void interval() throws InterruptedException {
        Observable.interval(1, TimeUnit.SECONDS)
                .subscribe(t -> System.out.println(t));

        TimeUnit.SECONDS.sleep(5);
    }

每隔一秒输出一个从 0 递增的数，本例输出到 4

timer

创建一个 Observable，在给定延迟后发射一个空消息

demo

	static void timer() {
        Observable.timer(2, TimeUnit.SECONDS)
                .subscribe(t -> System.out.println(t));
    }

repeat

创建一个重复发射特定数据多次的 Observable

demo

	static void repeat() {
        Observable.just("test")
                .repeat(2)
                .subscribe(t -> System.out.println(t));
    }

重新两次输出 test

repeatWhen

它 不是 缓存和重放原始 Observable 的数据序列，而是有条件地 重新订阅和发射 原来的 Observable

demo

	static void repeatWhen() throws InterruptedException {
        Observable.just("test")
                .repeatWhen(o -> {
                    return Observable.timer(3, TimeUnit.SECONDS);
                })
                .subscribe(t -> System.out.println(t));

        TimeUnit.SECONDS.sleep(5);
    }

发射 test 三秒后再次 重新订阅与发射

repeatUtil

表示直到某个条件就不再发射，接受一个 BooleanSupplier，返回 false，重复发射，反之终止发射

demo

	static void repeatUtil() {
        AtomicInteger i = new AtomicInteger(0);

        Observable.just("test")
                .repeatUntil(() -> {
                    return i.incrementAndGet() > 5;
                }).subscribe(t -> System.out.println(t));
    }

重复 5 次，共输出 6 次

总结

本章节介绍了 RxJava 的 创建操作符，下章节解读 变换操作符、过滤操作符

上一篇：【从零学 RxJava】RxJava 1 Hot Observable & Cold Observable、Subject

下一篇：【从零学 RxJava】RxJava 3 —— 变换操作符、过滤操作符

github

文中涉及的示例 demo：

https://github.com/dangzhicairang/rxjava.git

参考

RxJava 2.x 实战 —— 沈哲