RxJava3.0 操作符:创建操作符使用

RxJava3.0 操作符之创建操作符使用

创建操作符

用来创建一个新的可观察对象,下面介绍一些常用创建操作符

• create 直接创建一个可观察对象
• just 将一个对象或一组对象转换为发出该对象或那些对象的可观察对象
• fromArray/fromIterable 一组对象转换为发出该对象或那些对象的可观察对象
• defer 在观察者订阅之前不会创建可观察对象，订阅行为发生时才为每个观察者创建一个新的可观对象
• interval 创建一个可观察对象，该可观察对象发出一个以指定时间间隔分隔的整数序列
• timer 创建一个在给定延迟后发出单个项目的可观察对象
• rang 创建一个发出一系列连续整数范围的可观察对象
• empty 创建一个不发射任何项目但正常终止的可观察对象
• error 创建一个不发出任何项目并终止并显示错误的可观察对象
• never 创建不发出任何项目且不终止的可观察对象

创建操作符的简单使用

create操作符的使用

 	//create 操作符 使用
    private void createOperator(){
         Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                //emitter 发射器用来发射 事件
                emitter.onNext("hello");
                emitter.onNext("RxJava");
                // onComplete 事件发发射后,可以继续onNext事件,但下面观察者不会再接收事件
                // onComplete 事件与onError 事件互斥
                // onComplete 后再发射onError 会出异常.崩溃
                // onError 后再发射 onComplete 接收error后 不再接收任何事件
                emitter.onError(new Throwable("出错了"));
                emitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
             @Override
             public void onSubscribe(@NonNull Disposable d) {
                 //onSubscribe 一旦订阅,会立马回调此方法
                 Log.i("operator create", "onSubscribe: ");
             }

             @Override
             public void onNext(@NonNull String s) {
                 //上面发射 onNext 事件 ,此处就可以收到
                 Log.i("operator create", "onNext");
             }

             @Override
             public void onError(@NonNull Throwable e) {
                 //上面发射 onError 事件,此处可以收到
                 Log.i("operator create", "onError");
             }

             @Override
             public void onComplete() {
                 //上面发射 onComplete 事件,此处可以收到
                 Log.i("operator create", "onComplete");
             }
         });
    }

just 操作符的使用

just 操作符创建一个可观察者对象,再订阅后,自动将一个或多个对象使用onNext发射出去,最后再发射onComplete事件.

	//just操作符
    private void justOperator(){
        //自动发射一个onNext事件
        Observable<Integer> just = Observable.just(1);
        //自动发射多个onNext事件,内部实际使用fromArray 操作符创建可观察对象
        Observable<String> just1 = Observable.just("hello", "world");
        //Consumer 消费者,如果只想关注onNext 事件,不关注其他事件的接收,可以只传递一个Consumer对象
        //当然此方法也有重载方法,可观察一个或多个事件 传递两个就是关注 next error 三个就是 next error complete
        just.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Throwable {
                Log.i("operator ", "accept: "   integer);
            }
        });

        just1.subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Throwable {
                Log.i("operator just", "accept: "   s);
            }
        });
    }

fromArray/fromIterable操作符的使用

fromArray 传递一组同类型的对象.返回一个可观察者对象,订阅后,将这组数据对象依次发出.

fromIterable 传递 Iterable<@NonNull ? extends T> 将集合中对象 依次发出

	 //fromArray/fromIterable
    private void fromOperator() {
        //fromArray
        Observable<Integer> integerObservable = Observable.fromArray(1, 2, 3);
        Observable<String> stringObservable = Observable.fromArray("a", "b", "c");
        integerObservable.subscribe(integer -> {
            Log.i("operator fromArray", " "   integer);
        });
        stringObservable.subscribe(s -> {
            Log.i("operator fromArray", " "   s);
        });
        
        //fromIterable
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("RxJava");
        list.add("RxAndroid");
        Observable.fromIterable(list).subscribe(s -> {
            Log.i("operator fromIterable", " "   s);
        });
    }

defer 操作符的使用

defer 操作符会延迟创建可观察者对象,只有当调用subscribe时,才会调用get() 方法去自己创建一个可观察对象,每次订阅都会创建一个新的可观察对象

private void deferOperator() {
        Observable<String> defer = Observable.defer(new Supplier<ObservableSource<String>>() {
            @Override
            public ObservableSource<String> get() throws Throwable {
                //下面定于代码被注释掉时,此处方法不会被调用,也就是说下面return 的可观察者对象不会被创建,
                //放开注释,当订阅代码调用时,再观察者 onSubscribe之前 就会调用get()方法来创建可观察者对象
                Log.i("operator defer", " defer get ");
                return Observable.just("a", "b", "c");
            }
        });


//        defer. subscribe(new Observer<String>() {
//            @Override
//            public void onSubscribe(@NonNull Disposable d) {
//                Log.i("operator defer","defer onSubscribe");
//
//            }
//
//            @Override
//            public void onNext(@NonNull String s) {
//                Log.i("operator defer","defer onNext : "  s);
//
//            }
//
//            @Override
//            public void onError(@NonNull Throwable e) {
//                Log.i("operator defer","defer onError");
//
//            }
//
//            @Override
//            public void onComplete() {
//                Log.i("operator defer","defer onComplete");
//
//            }
//        });
    }

interval 操作符的使用

以指定间隔时间 发送从0开始的整数序列

//interval 
private void intervalOperator() {
    //arg1 : 延迟几秒发射
    //arg2 : 发射间隔时间
    //arg3 : 时间单位
    Observable<Long> interval= Observable.interval(2L, 2L, TimeUnit.SECONDS);
    // 开始每隔两秒发送从0开始的整数序列
    interval.subscribe(aLong -> Log.i("operator interval", "interval onNext : "   aLong));
}

rang操作符的使用

 	private void rangOperator() {
        // 发送 3-9 的连续整数
        Observable.range(3, 9).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Throwable {
                Log.i("operator range", "range onNext : "   integer);
            }
        });
    }

timer 操作符的使用

    private void timerOperator() {
        //延迟一秒 开始发射事件(只发射一次)
        Observable<Long> timer = Observable.timer(1000L, TimeUnit.MILLISECONDS);

        timer.subscribe(aLong -> Log.i("operator timer", "timer onNext : "   aLong));
    }

empty / error /never

此三个操作符使用特别简单,就不上代码了

empty 操作符创建一个不发射任何项目单正常终止的可观察对象, 观察者处会回调 onSubscribe 及onComplete

error操作符 创建一个不发射任何项目并显示错误的可观察对象.会回调onSubscribe 及onError

never操作符 创建不发出任何项目且不终止的可观察对象,今会回调onSubscribe

end

还有其他一些不常使用的,实际用到了再去研究…

这篇好文章是转载于：学新通技术网