RxJava2 -- 创建操作符学习笔记

这篇学习笔记主要是参考了Android RxJava：最基础的操作符详解 - 创建操作符这篇博客进行学习的。博主的文章图文并茂，讲解的非常细致，可以点击上面的蓝色字体或者点击这里查看原文，如果链接失效，这里是原始连接:www.jianshu.com/p/e19f8ed86…

这篇学习笔记主要根据上面提到的文章对每一个创建操作符进行了学习，包括了每一个操作符的代码示例，同时对Observable.create(ObservableOnSubscribe).subscribe(Observer)的源码进行一点点追踪，下面是笔记的正文:

本篇学习笔记中使用的RxJava版本:

implementation 'io.reactivex.rxjava2:rxjava:2.2.21'

RxJava创建操作符

`基本创建`

`create()`

在上一篇笔记的学习中，我们已经知道如何使用create()方法创建一个被观察者，如下所示:

        Observable.create(object : ObservableOnSubscribe<Int> {
            @SuppressLint("CheckResult")
            override fun subscribe(emitter: ObservableEmitter<Int>) {
                for (i in 0 until  10)
                    emitter.onNext(i)
                emitter.onComplete()
            }
        }).subscribe()

上面的代码我们通过create(ObservableOnSubscribe)方法创建了一个被观察者，其中传递了一个ObservableOnSubscribe实例，当代码执行到subscribe()的时候，ObservableOnSubscribe中的subscribe()方法便会被执行，从而调用了ObservableEmitter发射数据。下面是对于create()方法源码的简单追踪：

create(ObservableOnSubscribe)：

    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

可以看到，在这个方法中，首先对传入的参数执行了判空的操作，然后创建了ObservableCreate(source)方法，创建了一个ObservableCreate实例，并将我们之前创建的ObservableOnSubscribe实例传递进去:

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
...省略其它源码...
}

在这里只是将我们传递进去的参数保存下来，需要注意的是ObservableCreate继承自Observable。

RxJavaPlugins.onAssembly(ObservableCreate)

当创建完ObservableCreate，接下来会执行RxJavaPlugins.onSddembly(ObservableCreate)方法，这个方法的源码如下:

    @NonNull
    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

在这个方法中，首先会获取onOnservableAssembly这个变量，然后判断这个变量是否为空，为空则直接将我们传递进来的参数返回，我们先看这个变量的定义和赋值:

//变量默认为null    
@Nullable
static volatile Function<? super Observable, ? extends Observable> onObservableAssembly;

//只在这里对参数进行了赋值    
public static void setOnObservableAssembly(@Nullable Function<? super Observable, ? extends Observable> onObservableAssembly) {
    if (lockdown) {
        throw new IllegalStateException("Plugins can't be changed anymore");
    }
    RxJavaPlugins.onObservableAssembly = onObservableAssembly;
}

//上面的方法只在这里进行了调用
public static void reset() {
    ...其它代码...
    setOnObservableAssembly(null);
    ...其它代码...
}

也就是说，如果我们没有手动调用RxJavaPlugins.setOnObservableAssembly()方法的话，onObservableAssembly就是null，因此，RxJavaPlugins.onAssembly()方法返回的就是我们传递进去的那个ObservableCreate。

至此，我们就了解了，当我们调用Observable.create()方法的时候，其实会获得一个ObservableCreate实例，这个实例中保存了我们传递的ObservableOnSubscribe实例。

ObservableCreate.subscribe()

创建完被观察者，接下来就会通过订阅将连接被观察者和观察者，如下所示:

.subscribe{
            Logs.e("observableWithCreate onNext:$it")
        }

在这里我们只传递了onNext()方法中的函数体，下面进入到这个方法的源码中:

    //直接调用的此方法
    public final Disposable subscribe(Consumer<? super T> onNext) {
        return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
    }
    //间接调用的此方法
        @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
            Action onComplete, Consumer<? super Disposable> onSubscribe) {
        ObjectHelper.requireNonNull(onNext, "onNext is null");
        ObjectHelper.requireNonNull(onError, "onError is null");
        ObjectHelper.requireNonNull(onComplete, "onComplete is null");
        ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");

        LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);

        subscribe(ls);

        return ls;
    }

从源码可以看出，我们的subscribe()其实最终会调用到上面的第二个方法，在这个方法中首先对传入的参数进行了判空，接着创建了一个LambdaObser对象，我们现在只需要知道这个LambdaObserver实现了Observer接口，和Observer是一样的，接下来调用了subscribe(Observer)这个方法，这个方法的源码如下:

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        	//其它源码
            subscribeActual(observer);
        	//其它源码

    }
	
    protected abstract void subscribeActual(Observer<? super T> observer);

在这个方法中主要就是调用了subscribeActual(observer)这个方法，这是一个抽象方法，需要子类去实现，通过上面的源码，我们已经了解，此时我们的被观察者是ObservableCreate这个类的对象，那么我们就进入这个类中查找:

//ObservableCreate中的subscribeActual()
	final ObservableOnSubscribe<T> source;
    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

在这个方法中，我们首先创建了一个发射器CreateEmitter,然后我们发现了source.subscribe(parent)方法，从上面的源码可以知道，这个source就是我们在Observable.create(ObservableOnSubscribe)方法中传递的ObservableOnSubscribe对象，也就是在这里调用了我们传入的ObservableOnSubscribe.subscribe(emitter)方法。

ObservableOnSubscribe.subscribe()

通过上面的了解，我们已经知道了在何时调用ObservableOnSubscribe.subscribe()方法，一般我们都是在这里写发送事件的代码，而且在上面的源码中，我们知道调用ObservableOnSubscribe.subscribe(ObservableEmitter)这个方法中传递的是一个CreateEmitter，也就是说我们调用的emitter.onNext()，emitter.onComplete()这些方法都是调用的CreateEmitter里面的相关方法，下面是CreateEmitter里面的onNext()方法的源码:
```
 @Override
        public void onNext(T t) {
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }
```
可以看到，这里就是直接调用的Observer中的onNext()方法。

至此，我们就了解了Observable.create(ObservableOnSubscribe).subscribe(Observer)的整个流程，总的来说就是首先创建一个发射器ObservableOnSubscribe，然后创建一个ObservableCreate并将这个发射器传递进去保存下来，等到调用Observable.subscribe(Observer)方法时根据传入的Observer生成一个CreateEmitter,并通过调用发射器的subscribe()方法调用CreateEmitter中的相关方法发射数据。

快速创建 & 发送事件

`just()`

使用这个方法可以快速创建被观察者对象，这个方法中直接发送传入的事件，最多可以发送10个事件，just()方法有10个重载函数，分别包括了1到10个可传入的参数:

        Observable.just(1, 2, 3, 4, 5, 6)
            .subscribe {
                Logs.e("observableWithJust onNext: $it")
            }

通过上面的方法我们就使用just()创建了一个被观察者，上面的代码相当于依次调用onNext(1),onNext(2),onNext(3),onNext(4),onNext(5),onNext(6)。当然源码方面并不是这么实现的，但是了解了Observable.create()的过程，这里just()方法的调用过程也是差不多的，只是内部创建的Observable和Disposable不一样，但是执行过程都是差不多的。

运行效果如下:

    onNext: 1
    observableWithJust onNext: 2
    observableWithJust onNext: 3
    onNext: 4
    observableWithJust onNext: 5
    observableWithJust onNext: 6

`fromArray()`

这个方法的作用是快速创建一个被观察者对象，直接将传入的数组数据发射出去。上面的just()内部也是使用的fromArray()。下面的代码演示了这个方法的使用:

    private fun observableWithFromArray() {
        val intArray = arrayOf<Int>(1, 2, 3, 4, 5, 6, 7)
        Observable.fromArray(*intArray)
            .subscribe {
                Logs.e("observableWithFromArray onNext:$it")
            }
    }

需要注意的是:由于Observable.fromArray(vararg)需要传入的是vararg类型的参数，如果我们直接将intArray作为参数传递进去，那么Observable.fromArray()就会认为这是一个IntArray类型的参数，所以这里传递的参数是*intArray，可以认为是将数组转换为vararg类型。

使用这个方法还可以对数组进行遍历。

运行效果如下:

    observableWithFromArray onNext:1
    observableWithFromArray onNext:2
    observableWithFromArray onNext:3
    observableWithFromArray onNext:4
    observableWithFromArray onNext:5
    observableWithFromArray onNext:6
    observableWithFromArray onNext:7

`fromIterable()`

快速创建一个被观察者对象，将集合中的元素依次发射出去，可用于快速创建被观察者对象并且需要发送多个数据的，也可以用于遍历集合，代码如下:

        val list = mutableListOf<String>("2321", "123123", "ASAs")
        Observable.fromIterable(list)
            .subscribe {
                Logs.e("observableWithFromIterable onNext:$it")
            }

运行结果如下:

    observableWithFromIterable onNext:2321
    observableWithFromIterable onNext:123123
    observableWithFromIterable onNext:ASAs

`never()`，`empty()`，`error()`

这三个方法主要用于测试使用，平时用到的比较少，其中:

never()创建的被观察者不会发送任何事件;
empty()创建的被观察者只会发送onComplete()事件;
error()创建的被观察者只会发送onError()事件，可以自定义错误类型。

`never()`

    private val mObserver = object : Observer<Any?> {
        override fun onSubscribe(d: Disposable) {
            Logs.e("observableWithNever onSubscribe...")
        }

        override fun onError(e: Throwable) {
            Logs.e("observableWithNever onError...")
        }

        override fun onComplete() {
            Logs.e("observableWithNever onComplete...")
        }

        override fun onNext(t: Any) {
            Logs.e("observableWithNever onNext...$t")
        }
    }        

Observable.never<Any?>()
            .subscribe(mObserver)
    }

上面的代码运行结果如下:

observableWithNever onSubscribe...

可以看到，这里并没有发送任何事件。

`empty()`

        Observable.empty<Any>()
            .subscribe(mObserver)

运行结果如下:

    observableWithNever onSubscribe...
    observableWithNever onComplete...

可以看到，empty()会直接发送完成事件。

`error()`

        Observable.error<IllegalArgumentException>(IllegalArgumentException("仅仅是测试error()方法"))
            .subscribe(mObserver)

运行结果如下:

    observableWithNever onSubscribe...
    observableWithNever onError...java.lang.IllegalArgumentException: 仅仅是测试error()方法

这里就是直接调用了onError()方法，并且打印出的错误信息也和我们设置的错误信息一样。

延迟创建

延迟创建的操作符用于执行定时操作和周期性操作，定时操作：在经过了x时间后自动执行y，周期性操作：每隔x的时间后自动执行y。

`defer()`

这个操作符的作用是:直到有观察者(Observer)订阅时，才动态创建被观察者(Observable)对象然后发送事件。这个操作符是通过Observable工厂方法创建被观察者对象，每次订阅后，都会得到一个刚创建的最新的Observable对象，这可以确保Observable里面的数据是全新的。

        //开始的数据
        var startNum = 10
        //通过defer创建被观察者,需要返回一个Observable对象，这里使用just
        var deferObservable = Observable.defer(object : Callable<ObservableSource<Int>> {
            override fun call(): ObservableSource<Int> {
                Logs.e("创建Observable")
                return Observable.just(startNum)
            }
        })
        //重新对数据进行赋值
        startNum = 100
        //创建观察者并开始订阅
        var observer = object : Observer<Int> {
            override fun onSubscribe(d: Disposable) {
                Logs.e("observableWithDefer 开始订阅:onSubscribe():$d")

            }

            override fun onNext(t: Int) {
                Logs.e("observableWithDefer 获取到数据$t")
            }

            override fun onError(e: Throwable) {
                Logs.e("observableWithDefer onError:$e")
            }

            override fun onComplete() {
                Logs.e("observableWithDefer onComplete....")
            }

        }
        Logs.e("开始订阅...")
        //开始订阅
        deferObservable.subscribe(observer)
    }

程序运行输出的日志如下:

    开始订阅...
    创建Observable
    observableWithDefer 开始订阅:onSubscribe():0
    observableWithDefer 获取到数据100
    observableWithDefer onComplete....

可以看到：这里确实是在执行了Observable.subscribe(Observer)方法之后才开始创建的被观察者，所以被观察者发送的数据也就是修改后的数据。

`timer()`

这个方法的作用是:快速创建一个被观察者，并在到达指定的延迟时间后，发送1个数值0(Long类型),代码如下:

        Observable.timer(3, TimeUnit.SECONDS)
            .subscribe({
                Logs.e("observableWithTimer onNext:$it")
            }, {
                Logs.e("observableWithTimer onError:$it")
            }, {
                Logs.e("observableWithTimer onComplete...")
            }, {
                Logs.e("observableWithTimer 开始订阅:$it")
            })

参数说明:

第一个参数"3"表示要延迟的时间
第二个参数TimeUnit.SECONDS表示时间单位，前两个参数共同组成了要延迟的具体时间
第三个参数是在timer()的重载函数中有，我们可以指定一个Scheduler，这里默认使用的是Scheduler.computation()

打印结果如下:

2021-03-25 16:01:42.892 22372-22372/com.project.mystudyproject E/com.project.mystudyproject: observableWithTimer 开始订阅:null
2021-03-25 16:01:45.897 22372-22422/com.project.mystudyproject E/com.project.mystudyproject: observableWithTimer onNext:0
2021-03-25 16:01:45.900 22372-22422/com.project.mystudyproject E/com.project.mystudyproject: observableWithTimer onComplete...

通过日志前面的时间线可以看出，订阅之后就会马上调用onSubscribe(Disposable)，等待3秒之后会获取到数据0并打印onComplete...。上面的observableWithTimer 开始订阅:null并不代表Disposable为空，这里的Disposable并不为空，是可以直接使用的。

`interval()`

这个方法的作用是：快速创建一个被观察者Observable，每隔指定的时间就发送一次事件。测试代码如下:

        var disposable: Disposable? = null
        var num: Long = -1
        Observable.interval(3, 1, TimeUnit.SECONDS)
            .subscribe({
                num = it
                Logs.e("observableWithInterval onNext: $it")
                if (num > 20)
                    disposable?.dispose()
            }, {
                Logs.e("observableWithInterval onError: $it")
            }, {
                Logs.e("observableWithInterval onComplete...")
            }, {
                disposable = it
                Logs.e("observableWithInterval onSubscribe:$it")
            })
    }

参数说明：

第一个参数3表示第一次发送事件的延迟时间，可以不指定，如果不指定就取第二个参数设置的间隔时间
第二个参数1表示后续发送事件的间隔时间，必须指定
第三个参数TimeUnit.SECONDS表示时间单位
重载方法中还可以指定Scheduler，不指定默认为Schedulers.computation()

运行结果如下:

2021-03-25 16:25:08.595 23896-23896/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onSubscribe:null
2021-03-25 16:25:11.599 23896-23951/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onNext: 0
2021-03-25 16:25:12.598 23896-23951/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onNext: 1
2021-03-25 16:25:13.599 23896-23951/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onNext: 2
2021-03-25 16:25:14.599 23896-23951/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onNext: 3

从打印日志可以看出，订阅之后，第一次发送事件间隔时间为3秒，后续每隔1秒发送一次事件。

修改代码，不指定第一次的延迟时间:

        var disposable: Disposable? = null
        var num: Long = -1
        Observable.interval( 3, TimeUnit.SECONDS)
            .subscribe({
                num = it
                Logs.e("observableWithInterval onNext: $it")
                if (num > 20)
                    disposable?.dispose()
            }, {
                Logs.e("observableWithInterval onError: $it")
            }, {
                Logs.e("observableWithInterval onComplete...")
            }, {
                disposable = it
                Logs.e("observableWithInterval onSubscribe:$it")
            })
    }

上面的代码中取消了第一次发送事件的延迟时间，只设置了发送事件的间隔时间为3s，最终打印数据如下:

2021-03-25 16:27:31.292 24066-24066/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onSubscribe:null
2021-03-25 16:27:34.298 24066-24139/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onNext: 0
2021-03-25 16:27:37.296 24066-24139/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onNext: 1
2021-03-25 16:27:40.297 24066-24139/com.project.mystudyproject E/com.project.mystudyproject: observableWithInterval onNext: 2

可以看到，订阅之后过了3s开始发送第一次事件，后续每隔3s发送一次事件。

`intervalRange()`

这个方法的特点是:快速创建一个被观察者对象，每隔指定的时间就发送事件，可以指定发送事件的数量，发送的事件序列为从0开始，每次递增1的整数序列。与interval()的区别主要在于可以指定发送事件的数量。

        Observable.intervalRange(10, 6, 3, 1, TimeUnit.SECONDS)
            .subscribe({
                Logs.e("observableWithIntervalRange onNext: $it")
            }, {
                Logs.e("observableWithIntervalRange onError:$it")
            }, {
                Logs.e("observableWithIntervalRange onComplete...")
            }, {
                Logs.e("observableWithIntervalRange onSubscribe:$it")
            })

参数说明:

第一个参数10表示开始发送事件的数据，这里表示从10开始
第二个参数6表示一共发送6个事件，从10到15
第三个参数3表示第一次发送事件的延迟时间
第四个参数1表示后续每次发送事件的间隔时间
第五个参数TimeUnit.SECONDS表示时间单位，结合两个参数使用
重载方法中还可以指定Scheduler参数，不指定的时候使用Schedulers.computation()

运行结果如下:

2021-03-25 16:40:28.233 24420-24420/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onSubscribe:null
2021-03-25 16:40:31.237 24420-24681/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onNext: 10
2021-03-25 16:40:32.236 24420-24681/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onNext: 11
2021-03-25 16:40:33.236 24420-24681/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onNext: 12
2021-03-25 16:40:34.236 24420-24681/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onNext: 13
2021-03-25 16:40:35.236 24420-24681/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onNext: 14
2021-03-25 16:40:36.236 24420-24681/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onNext: 15
2021-03-25 16:40:36.236 24420-24681/com.project.mystudyproject E/com.project.mystudyproject: observableWithIntervalRange onComplete...

可以看到，订阅成功后，第一次发送事件的事件延迟为3s,后续每隔1s发送一次事件，一共发送了6次，接着调用了onComplete完成。

`range()`

这个方法的特点是:快速创建一个被观察者对象，连续发送一个事件序列，可以指定范围。发送的事件序列也是从0开始，每次递增1，直到达到指定的发送数量。与intervalRange()的区别在于不会延迟和间隔。

        Observable.range(100, 10)
            .subscribe({
                Logs.e("observableWithRange onNext: $it")
            }, {
                Logs.e("observableWithRange onError:$it")
            }, {
                Logs.e("observableWithRange onComplete...")
            }, {
                Logs.e("observableWithRange onSubscribe:$it")
            })

参数说明:

第一个参数100表示开始发送事件的数据，也就是第一个事件的数据是100
第二个参数10表示一共发送10个数据，在这段代码中就是从100到109

运行结果如下:

2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onSubscribe:0
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 100
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 101
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 102
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 103
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 104
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 105
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 106
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 107
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 108
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onNext: 109
2021-03-25 16:52:05.379 25010-25010/com.project.mystudyproject E/com.project.mystudyproject: observableWithRange onComplete...

可以看到：订阅成功后就立即开始发送事件，没有延迟，中间也没有间隔。

`rangeLong()`

这个方法和range()方法的作用是一样的，只是数据类型为Long。

        Observable.rangeLong(100, 10)
            .subscribe({
                Logs.e("observableWithRangeLong onNext: $it,type is${it::class.java.name}")
            }, {
                Logs.e("observableWithRangeLong onError:$it")
            }, {
                Logs.e("observableWithRangeLong onComplete...")
            }, {
                Logs.e("observableWithRangeLong onSubscribe:$it")
            })

运行结果如下:

2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onSubscribe:0
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 100,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 101,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 102,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 103,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 104,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 105,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 106,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 107,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 108,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onNext: 109,type isjava.lang.Long
2021-03-25 17:06:41.221 25745-25745/com.project.mystudyproject E/com.project.mystudyproject: observableWithRangeLong onComplete...

可以看到这里onNext()里面的数据确实为Long类型。

RxJava2 -- 创建操作符学习笔记

RxJava创建操作符

基本创建

create()

快速创建 & 发送事件

just()

fromArray()

fromIterable()

never()，empty()，error()

never()

empty()

error()

延迟创建

defer()

timer()

interval()

intervalRange()

range()

rangeLong()

`基本创建`

`create()`

`just()`

`fromArray()`

`fromIterable()`

`never()`，`empty()`，`error()`

`never()`

`empty()`

`error()`

`defer()`

`timer()`

`interval()`

`intervalRange()`

`range()`

`rangeLong()`