Rxjava2的笔记1 --操作符_observable.just传入多参数-CSDN博客

本文链接：https://blog.csdn.net/qq873044564/article/details/108073746

本文详细介绍了RxJava2中的各种操作符，包括创建、转换、过滤、组合、错误处理、辅助、条件和布尔以及聚合操作符，并通过实例展示了它们的使用方法，如create、map、flatmap、filter、merge、concat、retry、delay等，帮助读者理解RxJava2的事件处理和数据流管理。

摘要由CSDN通过智能技术生成

本篇文章总结了Rxjava2中的各种操作符以及对应的例子

参考视频:https://edu.csdn.net/course/play/10036/215978

依赖

创建操作符

create :创建操作符,创建最简单的事件流

from把一个团分开,然后分别发射

just直接发射当前的数据流,可发送多个参数,最多10个

defer等到订阅的时候,才会发射事件流,会随最新的数据变化

interval 每隔一段时间发射一次,一直重复

range发射一个范围内的整数数据流,范围为n 到 n+m-1

flatmap类型转换,返回的是包含结果集的Observable,即包装成另一个数据流,即多重转换

groupBy操作符将发射出来的数据项进行分组,并将分组后的数据项保存在key-value映射的事件流中

scan会对发射的数据和上一轮发射的数据进行函数处理,并返回数据提供给下一轮使用

buffer:对发射出来的数据进行一定数量的缓存,然后分组发射,发射出来的是新的数据流

window:也是缓存作用,和buffer不同的是window操作符发出的是一个新的事件流,即新的事件流中的数据项还可以经过其他操作符进行处理.

过滤操作符

debounce:过滤掉发射速率过快的数据项,如网络请求,在一段时间内只取最后一次操作

distinct过滤重复发射的数据项

elementAt() 输出下标为几的数据

filter过滤出满足条件的值

first():输出第一项的数据,参数为默认值

ignoreElements() :忽略元素只处理最后的onComplete()方法

last: 输出最后一项,参数为默认值

sample:采样,每隔一段时间去采样一次

merge/concat将2个事件流合并为1个发射

zip:将两个数据流按照指定的函数规则合并为一个数据流,一同发出

startWith将另一个数据流合并到原数据流的开头,一同发出

join:将数据流排列组合发出,有时间期限的合并操作符

combineLastest会寻找其他事件流最近发射的数据流进行合并然后一同发出

错误处理操作符

onErrorReturn当错误发生时,会忽略onError的回调且会发射一个新的数据项并回调onCompleted()

onErrorResumeNext表示当错误发生时,会忽略onError的回调且会发射一个新的事件流并回调onCompleted()

onExceptionResumeNext表示收到的是Exception,会回调备用的事件流进行数据的发射;

如果不是一个Exception,如注释的Error,会回调onError方法

retry表示当错误发生时,发射器会重新发射,参数决定重新几次

retryWhen:与retry类似,区别在于retryWhen将Throwable传递给了函数进行处理并产生新的事件流进行处理

辅助性操作符

delay延时某次事件发送的数据流

do:可以用来监听整个事件流的生命周期

materialize/dematerialize:对事件流进行装箱/解箱

serialize:可以将异步执行的事件流进行同步操作,直到事件流结束,应该用到多线程

timeInterval:将发射的数据项转换为带有时间间隔的数据项,就是将事件间隔包装为一个对象进行发射

timeout:当发射的数据项超过了规定的时间,则发射onError事件

timeStamp:给每个发射的数据带上时间戳

Using:可以让你的事件流存在一次性的数据项,即用完就将资源释放掉

条件和布尔操作符

all:所有的数据项都满足条件则为true,否则返回false

contains:是否包含某项数据

amb:在多个事件流中只发射最先发射的事件流

defaultEmpty:如果为空的话发射的数据项

sequenceEqual:看两个数据流是否相等

skipUtils:两个事件流发射的时候,第一个事件流会等到第二个事件流发射的时候,第一个事件流才开始发射数据

skipWhile:在一个事件中,判断是否符合某个特定条件,如果符合,则不发射,如果不符合则终止判断,发射剩余的所有数据

takeUtils:第一个事件流会发射到第二个事件流发射的时候停止发射

takeWhile:满足就发射,不满足的话后面的停止发射

聚合操作符

reduce:和scan操作符一样,会对发射的数据和上一轮的数据进行函数处理,并返回数据供下一轮使用,会输出最后的结果

collect:和reduce类似,还可以改变数据结构,如下就把Interger改为了String类型

连接操作符

publish + connect:publish把事件流转换为可连接的事件流,connect把可连接的事件流去连接,连接之后数据才会发射出来

refCount:将可连接的事件流转换为普通的事件流

replay操作符弥补了connect操作符的缺陷,可以将发射出去的操作符进行缓存,不会丢失发射出去的数据项

依赖

implementation 'io.reactivex.rxjava2:rxjava:2.2.6'
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'

创建操作符

create :创建操作符,创建最简单的事件流

其中Consumer为自定义观察者方法,不必全部实现观察者所有方法,此accept对应onNext()方法

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                for (int i = 0; i < 5; i++) {
                    emitter.onNext(i);
                }
                emitter.onComplete();
            }
        })
                .observeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "accept: " + integer);
                    }
                });

from把一个团分开,然后分别发射

 Observable.fromArray(1,2,3,4,5)
                .observeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "onNext: " + integer);
                    }
                });

just直接发射当前的数据流,可发送多个参数,最多10个

 Observable.just(1,2,3,4,5)
                .observeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "onNext: " + integer);
                    }
                });

defer等到订阅的时候,才会发射事件流,会随最新的数据变化

i = 10;
        Observable<Integer> just = Observable.just(i);
        Observable<Object> defer = Observable.defer(new Callable<ObservableSource<?>>() {
            @Override
            public ObservableSource<?> call() throws Exception {
                return Observable.just(i);
            }
        });

        i = 15;
        just.subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "just: " + integer );
            }
        });

        defer.subscribe(new Consumer<Object>() {
            @Override
            public void accept(Object o) throws Exception {
                Log.e(TAG, "defer: " + o );
            }
        });

输出

interval 每隔一段时间发射一次,一直重复

Observable.interval(1, TimeUnit.SECONDS)
               .subscribe(new Consumer<Long>() {
                   @Override
                   public void accept(Long aLong) throws Exception {
                       Log.e(TAG, "accept: " + aLong );
                   }
               });

range发射一个范围内的整数数据流,范围为n 到 n+m-1

 Observable.range(2, 5)
               .subscribe(new Consumer<Integer>() {
                   @Override
                   public void accept(Integer integer) throws Exception {
                       Log.e(TAG, "accept: " + integer );
                   }
               });

repeat重复几次

Observable.just(1).repeat(6)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "accept: "+(count++) +integer);
                    }
                });

Timer延时几秒去发射,只发射一次

 Observable.timer(2,TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.e(TAG, "accept: "+aLong );
                    }
                });

转换操作符

map对数据流进行类型转换

Observable.just(1).map(new Function<Integer, String>() {
            @Override
            public String apply(Integer integer) throws Exception {
                return "变为了字符串"+integer;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "accept: "+s );      
            }
        });

flatmap类型转换,返回的是包含结果集的Observable,即包装成另一个数据流,即多重转换

 Observable.just(new User("Tian",22)).flatMap(new Function<User, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(User user) throws Exception {
                return Observable.just(user.getName() + "登录成功");
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e(TAG, "accept: " + s);
            }
        });

class User{
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

map和flatMap的区别:

Map返回的是结果集,flatMap返回的是包含结果集的Observable

FlatMap可用于一对多,多对多,

flatMap和concatMap的区别

两者的用法相同,flatMap是乱序的,concatMap的有序的