RxJava 操作符篇 - 创建操作符_observable.create(new observableonsubscribe<intege-CSDN博客

本文介绍RxJava中创建Observable的各种方法，包括Create、Defer、From、Interval等，并提供了每种方法的使用示例和输出结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Create

创建Observable。

Observable.create(new ObservableOnSubscribe<Integer>() {
	   @Override
	   public void subscribe(@NonNull ObservableEmitter<Integer> emitter) throws Throwable {
	       try {
	           for (int i=0; i<10; i++) {
	               Thread.sleep(1000);
	               emitter.onNext(i);
	           }
	           emitter.onComplete();
	       } catch (Exception e) {
	           emitter.onError(e);
	       }
	   }
	})
       .subscribeOn(Schedulers.io())
       .observeOn(AndroidSchedulers.mainThread())
       .subscribe(new Observer<Integer>() {
           @Override
           public void onSubscribe(@NonNull Disposable d) {
               System.out.println(System.currentTimeMillis() + " - onSubscribe");
           }

           @Override
           public void onNext(@NonNull Integer integer) {
               System.out.println(System.currentTimeMillis() + " - onNext :" + integer);
           }

           @Override
           public void onError(@NonNull Throwable e) {
               System.out.println(System.currentTimeMillis() + " - onError");
           }

           @Override
           public void onComplete() {
               System.out.println(System.currentTimeMillis() + " - onComplete");
           }
       });

结果：

1601181104193 - onSubscribe
1601181105197 - onNext :0
1601181106198 - onNext :1
1601181107200 - onNext :2
1601181108201 - onNext :3
1601181109203 - onNext :4
1601181110205 - onNext :5
1601181111207 - onNext :6
1601181112208 - onNext :7
1601181113210 - onNext :8
1601181114211 - onNext :9
1601181114212 - onComplete

Defer

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

defer 方法默认不在任何特定的调度器上执行。

System.out.println(System.currentTimeMillis() + " - Observable.defer");

Observable observable = Observable.defer((Supplier<ObservableSource<String>>) () -> {
    String data = "Hello";
    System.out.println(System.currentTimeMillis() + " - Produce data : " + data);
    return Observable.just(data);
});

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

observable.subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(@NonNull Disposable d) {
        System.out.println(System.currentTimeMillis() + " - onSubscribe");
    }

    @Override
    public void onNext(@NonNull String s) {
        System.out.println(System.currentTimeMillis() + " - onNext :" + s);
    }

    @Override
    public void onError(@NonNull Throwable e) {
        System.out.println(System.currentTimeMillis() + " - onError");
    }

    @Override
    public void onComplete() {
        System.out.println(System.currentTimeMillis() + " - onComplete");
    }
});

结果：

1601189915540 - Observable.defer
1601189916544 - Produce data : Hello
1601189916548 - onSubscribe
1601189916549 - onNext :Hello
1601189916550 - onComplete

From

将数组、Iterable、Future、Callable、Completable、Maybe、Optional、Publisher、Runnable、Single、Stream等转换为Observable，对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。

from 默认不在任何特定的调度器上执行，可通过参数指定调度器。

Observable.fromArray(1, 2, 3, 4, 5)
        .subscribeOn(Schedulers.computation())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                System.out.println(System.currentTimeMillis() + " - onSubscribe");
            }

            @Override
            public void onNext(@NonNull Integer integer) {
                System.out.println(System.currentTimeMillis() + " - onNext :" + integer);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(System.currentTimeMillis() + " - onError");
            }

            @Override
            public void onComplete() {
                System.out.println(System.currentTimeMillis() + " - onComplete");
            }
        });

结果：

1601186428730 - onSubscribe
1601186428741 - onNext :1
1601186428741 - onNext :2
1601186428741 - onNext :3
1601186428742 - onNext :4
1601186428742 - onNext :5
1601186428742 - onComplete

Interval

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

interval 默认在 computation 调度器上执行。

System.out.println(System.currentTimeMillis() + " - Observable.interval");
Observable.interval(1, 2, TimeUnit.SECONDS)        
        .subscribe(new Observer<Long>() {

            Disposable disposable;

            @Override
            public void onSubscribe(@NonNull Disposable d) {
                disposable = d;
                System.out.println(System.currentTimeMillis() + " - onSubscribe");
            }

            @Override
            public void onNext(@NonNull Long aLong) {
                System.out.println(System.currentTimeMillis() + " - onNext :" + aLong);
                if (aLong > 9) {
                    disposable.dispose();
                }
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(System.currentTimeMillis() + " - onError");
            }

            @Override
            public void onComplete() {
                System.out.println(System.currentTimeMillis() + " - onComplete");
            }
        });

结果：

1601190625516 - Observable.interval
1601190625533 - onSubscribe
1601190626537 - onNext :0
1601190628537 - onNext :1
1601190630538 - onNext :2
1601190632538 - onNext :3
1601190634538 - onNext :4
1601190636538 - onNext :5
1601190638537 - onNext :6
1601190640538 - onNext :7
1601190642537 - onNext :8
1601190644537 - onNext :9
1601190646538 - onNext :10

Just

创建一个发射指定值的Observable，接受1~10个参数，返回一个按参数列表顺序发射这些数据的Observable。

Observable.just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        .subscribeOn(Schedulers.computation())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                System.out.println(System.currentTimeMillis() + " - onSubscribe");
            }

            @Override
            public void onNext(@NonNull Integer integer) {
                System.out.println(System.currentTimeMillis() + " - onNext :" + integer);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(System.currentTimeMillis() + " - onError");
            }

            @Override
            public void onComplete() {
                System.out.println(System.currentTimeMillis() + " - onComplete");
            }
        });

结果：

1601185725241 - onSubscribe
1601185725251 - onNext :1
1601185725251 - onNext :2
1601185725251 - onNext :3
1601185725252 - onNext :4
1601185725252 - onNext :5
1601185725252 - onNext :6
1601185725252 - onNext :7
1601185725252 - onNext :8
1601185725252 - onNext :9
1601185725252 - onNext :10
1601185725253 - onComplete

Range

创建一个发射一个范围内的有序整数序列的 Observable。

range 默认不在任何特定的调度器上执行，可通过参数指定调度器。

Observable.range(4, 6)
        .subscribeOn(Schedulers.computation())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                System.out.println(System.currentTimeMillis() + " - onSubscribe");
            }

            @Override
            public void onNext(@NonNull Integer integer) {
                System.out.println(System.currentTimeMillis() + " - onNext :" + integer);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(System.currentTimeMillis() + " - onError");
            }

            @Override
            public void onComplete() {
                System.out.println(System.currentTimeMillis() + " - onComplete");
            }
        });

结果：

1601190950498 - onSubscribe
1601190950501 - onNext :4
1601190950501 - onNext :5
1601190950501 - onNext :6
1601190950502 - onNext :7
1601190950502 - onNext :8
1601190950502 - onNext :9
1601190950502 - onComplete

Repeat

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

repeat 操作符默认在 trampoline 调度器上执行，也可指定调度器。

Observable.just(0, 1)
        .repeat(3)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                System.out.println(System.currentTimeMillis() + " - onSubscribe");
            }

            @Override
            public void onNext(@NonNull Integer integer) {
                System.out.println(System.currentTimeMillis() + " - onNext :" + integer);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(System.currentTimeMillis() + " - onError");
            }

            @Override
            public void onComplete() {
                System.out.println(System.currentTimeMillis() + " - onComplete");
            }
        });

结果：

1601191255024 - onSubscribe
1601191255039 - onNext :0
1601191255039 - onNext :1
1601191255040 - onNext :0
1601191255040 - onNext :1
1601191255040 - onNext :0
1601191255040 - onNext :1
1601191255040 - onComplete

Timer

创建一个在给定的时间段之后发射一个简单的数字0的 Observable。

timer 操作符默认在 computation 调度器上执行，可指定调度器。

Observable.timer(1, TimeUnit.SECONDS)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<Long>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                System.out.println(System.currentTimeMillis() + " - onSubscribe");
            }

            @Override
            public void onNext(@NonNull Long along) {
                System.out.println(System.currentTimeMillis() + " - onNext :" + along);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                System.out.println(System.currentTimeMillis() + " - onError");
            }

            @Override
            public void onComplete() {
                System.out.println(System.currentTimeMillis() + " - onComplete");
            }
        });

结果：

1601191683051 - onSubscribe
1601191684058 - onNext :0
1601191684059 - onComplete

Empty/Never/Throw

Empty：创建一个不发射任何数据但是正常终止的 Observable；
Never：创建一个不发射数据也不终止的 Observable；
Throw：创建一个不发射数据以一个错误终止的 Observable；

这三个操作符在测试的时候很有用，有时候也用于结合其他的 Observables，或者作为其他需要 Observable 的操作符的参数。

这些操作符默认不在任何特定的调度器上执行，但是 empty 和 error 有一个可选参数是 Scheduler，可以指定调度器。

Start

返回一个 Observable，它发射一个类似于函数声明的值。

start 操作符的多种 RxJava 实现都属于可选的 rxjava-async 模块。

这个函数只会被执行一次，即使多个观察者订阅这个返回的 Observable。

参考资料

RxJava中文文档