RxJava-创建操作符

1、RxJava的主要创建操作符

操作符	描述
just	将一个或多个对象转换成发射这个或这些对象的一个Observable
from	将一个Iterable、Future或者一个数组转换成一个Observable
create	使用一个函数从头创建一个Observable
defer	只有当订阅者订阅才创建Observable，为每个订阅创建一个新的Observable
range	创建一个发射指定范围的整数序列的Observable
interval	创建一个按照给定的时间间隔发送的整数序列的Observable
timer	创建一个指定的延时之后发射单个数据的Observable
empty	创建一个什么都不做直接通知完成的Observable
error	创建一个什么都不做直接通知错误的Observable
never	不发射任何数据

2、create

Rxjava建议我们在传递给create方法的函数时，检查观察者的isDisposed状态，以便在没有观察者的时候，让我们的Observable停止发射数据，防止运行昂贵的运算

  // create
        Observable.create(observableEmitter -> {
            try {
                // 官方建议判断是否观察者是否在处理中
                if (!observableEmitter.isDisposed()) {
                    for (int i = 0; i < 10; i++) {
                        observableEmitter.onNext(i);
                    }
                }
            } catch (Exception e) {
                observableEmitter.onError(e);
            } finally {
                observableEmitter.onComplete();
            }
        }).subscribe(
                // onNext
                System.out::println,
                // onError
                System.err::println,
                // onComplete
                () -> System.out.println("onComplete!!"),
                // onSubscribe
                (disposable) -> System.out.println("onSubscribe!!")
        );

3、just和from

   // just
        Observable.just("A", "B", "C")
                .subscribe(
                        // onNext
                        System.out::println,
                        // onError
                        System.err::println,
                        // onComplete
                        () -> System.out.println("onComplete!!"),
                        // onSubscribe
                        (disposable) -> System.out.println("onSubscribe!!")
                );

        // from 1
        Observable.fromArray("A", "B", "C")
                .subscribe(
                        // onNext
                        System.out::println,
                        // onError
                        System.err::println,
                        // onComplete
                        () -> System.out.println("onComplete!!"),
                        // onSubscribe
                        (disposable) -> System.out.println("onSubscribe!!")
                );

        // from 2
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> submit = executorService.submit(new TestCallable());
        // 超过1秒没有返回会抛出一个java.util.concurrent.TimeoutException异常
        Observable.fromFuture(submit, 1, TimeUnit.SECONDS)
                .subscribe(
                        // onNext
                        System.out::println,
                        // onError
                        System.err::println,
                        // onComplete
                        () -> System.out.println("onComplete!!"),
                        // onSubscribe
                        (disposable) -> System.out.println("onSubscribe!!")
                );

4、repeat

  // repeat
        Observable
                .just("A", "B", "C")
                // 数据重复发送3次
                .repeat(3)
                .subscribe(
                        // onNext
                        System.out::println,
                        // onError
                        System.err::println,
                        // onComplete
                        () -> System.out.println("onComplete!!"),
                        // onSubscribe
                        (disposable) -> System.out.println("onSubscribe!!")
                );

        // repeatWhen
        //有条件地重新订阅和发送原来地Observable
        Observable
                .range(0, 3)
                // 1秒后还会重新发送一次数据
                .repeatWhen(objectObservable -> Observable.timer(1, TimeUnit.SECONDS))
//                .repeatWhen(objectObservable -> Observable.just("A","B"))
                .subscribe(
                        // onNext
                        System.out::println,
                        // onError
                        System.err::println,
                        // onComplete
                        () -> System.out.println("onComplete!!"),
                        // onSubscribe
                        (disposable) -> System.out.println("onSubscribe!!")
                );
        TimeUnit.SECONDS.sleep(4);

        // repeatUntil
        // 知道某个条件就不再重复发射数据
        Observable.interval(500, TimeUnit.MILLISECONDS)
                .take(5)
                // true不重复 false 重复
                .repeatUntil(() -> true)
                .subscribe(System.out::println);

        TimeUnit.SECONDS.sleep(10);
    }

5、defer

 // defer
        // 每个订阅者都以为自己订阅的是同一个Observable，其实获取的都是自己单独的数据序列，线程安全
        Observable.defer(() -> Observable.just("A"))
                .subscribe(
                        // onNext
                        System.out::println,
                        // onError
                        System.err::println,
                        // onComplete
                        () -> System.out.println("onComplete!!"),
                        // onSubscribe
                        (disposable) -> System.out.println("onSubscribe!!")
                );