Rxjava创造操作符

rxjava 操作符kotlin 语法练习

依赖

    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
    implementation 'io.reactivex.rxjava2:rxjava:2.2.9'

经常会使用的固定式语句

1、异步订阅观察者 （切换到子线程）

  .subscribeOn(Schedulers.io())

2、排放到主线程执行

 .observeOn(AndroidSchedulers.mainThread())

3、订阅一个可被观察资源

.subscribe()

Observable的创建操作符

create、just、dafer 、from（fromArray 、fromFuture   、fromIterable 、 fromCallable）、range 、interval、intervalRange  、timer

1、create   创建新的Observable实例 

 Observable.create<Any> {
            it.onNext("创建一个可被观察的对象")
        }.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe {
                    println(it)
                }

2、just 发出每个项目的可观察对象

 Observable.just("1", "2", 5, 8, Any())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe {
                    println(it.toString())
                }

3、dafer     ObservableSource工厂函数   ，返回一个Observable，该Observable调用一个ObservableSource工厂来为每个新的Observer创建一个ObservableSource

   Observable.defer(object : Callable<Observable<String>> {
            override fun call(): Observable<String> {
                return Observable.create { it.onNext("haodada") }
            }
        }).subscribe {
            pprintln(it.toString())
        }

4、fromArray 一个发出源数组中的每个项的可观察对象

 Observable.fromArray("1", 5, 9, "5")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe {
                    println(it.toString())
                }

5、fromFuture   将{ Future}转换为ObservableSource。 

        var task = FutureTask(Callable<String> {
            "task ${Thread.currentThread().id}"
        })
        Observable.fromFuture(task)
            .subscribe({ s: String? -> pprintln(" onNext : ${s}") },
                { o: Throwable? -> pprintln(" onError : ${o}") },
                { pprintln(" onComplete!!") },
                { disposable: Disposable? ->
                    pprintln(" onSubscribe!!")
                    task.run()
                })

 6、fromIterable  将{ 集合}转换为ObservableSource。 

  var array = arrayListOf(1, 2, 2, 5, 6, 6, 9)
        Observable.fromIterable(array)
            .subscribe {
                pprintln(it.toString())
            }

 7、fromCallable 返回一个可观察对象，当一个观察者订阅它时，它会调用你指定的函数，然后发出从该函数返回的值。

  Observable.fromCallable { Math.abs(-5)}
            .subscribe {
                pprintln(it.toString())
            }

8、range  它发出指定范围内的一系列整数

       Observable.range(200,1000).subscribe {
            pprintln(it.toString())
        }

9、interval  返回一个可观察对象，它会在每一个指定的时间间隔发出一个连续的数字

Observable.interval(10,20,TimeUnit.MILLISECONDS)
            .subscribe {
                pprintln(it.toString())
            }

10、intervalRange （rang 范围  interval 间隔）  返回一个可观察对象，它会在每一个指定的时间间隔发出一个连续的数字。信号一个长值的范围，第一个在一些初始延迟后，其余的周期性后。

  Observable.intervalRange(10, 100, 200, 10, TimeUnit.MILLISECONDS)
            .subscribe {
                pprintln(it.toString())
            }

11、返回一个可观察对象，它在指定的延迟之后发出，然后完成。

 var disposable: Disposable// disposable.dispose() 事件的终止/重新计时
        Observable.timer(200, TimeUnit.MILLISECONDS)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe({
                pprintln(it.toString())
            }, {

            }, {

            }, {
                disposable = it
            })