Rxjava操作符讲解(2)Transforming 变换操作符

之前没有了解过Rxjava的童鞋,建议先阅读《Rxjava 从入门到开发》这篇文章,对入门比较有帮助。

map操作符

作用:通过call函数根据函数Func1<T,K>把T转换为K

List<Student> students=new ArrayList<>();
    Student stuent=new Student();
    stuent.setName("小一");
    Student s1=new Student();
    s1.setName("小二");
    students.add(stuent);
    students.add(s1);
    subscription=Observable.from(students).map(new Func1<Student, String>() {

        @Override
        public String call(Student student) {
            return student.getName();
        }
    }).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Logger.i("MapOperation : "+s);
        }
    });

输出结果:

例子说明:通过map操作符,我们把输入的Student对象转换成了String变量,然后遍历输出。

flag map操作符

作用:对序列的每一项通过call函数根据函数Func1<T,Observable<K>>把T通过操作符转换为K

Observable.just(10, 20, 30).flatMap(new Func1<Integer, Observable<Integer>>() {
        @Override
        public Observable<Integer> call(Integer integer) {
            //10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
            int delay = 200;
            if (integer > 10)
                delay = 180;

            return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
        }
    }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            System.out.println("flatMap Next:" + integer);
        }
    });

输出结果:

例子说明:输入数字10,20,30通过操作符from和delay输出,这里要注意的是,输出结果已经出现了乱序,即没有按照10,5;20,10;30,15的顺序输出。

concatMap操作符

作用:对序列的每一项通过call函数根据函数Func1<T,Observable<K>>把T通过操作符转换为K,相对于flatmap可以保证输出顺序一致

Observable.just(10, 20, 30).concatMap(new Func1<Integer, Observable<Integer>>() {
        @Override
        public Observable<Integer> call(Integer integer) {
            //10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
            int delay = 200;
            if (integer > 10)
                delay = 180;

            return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
        }
    }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            System.out.println("concatMap Next:" + integer);
        }
    });

输出结果:

例子说明:输入数字10,20,30通过操作符from和delay输出,这里要注意的是,输出结果没有出现乱序

switchMap操作符

作用:对序列的每一项通过call函数根据函数Func1<T,Observable<K>>把T通过操作符转换为K,若结果k1,k2同时出现则则会保留最新的k2,丢弃k1

Observable.just(10, 20, 30).switchMap(new Func1<Integer, Observable<Integer>>() {
        @Override
        public Observable<Integer> call(Integer integer) {
            //10的延迟执行时间为200毫秒、20和30的延迟执行时间为180毫秒
            int delay = 200;
            if (integer > 10)
                delay = 180;

            return Observable.from(new Integer[]{integer, integer / 2}).delay(delay, TimeUnit.MILLISECONDS);
        }
    }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            System.out.println("switchMap Next:" + integer);
        }
    });

输出结果:

例子说明:输入数字10,20,30通过操作符from和delay输出,但是由于switchmap操作符的作用,10的输出被20覆盖,20的输出结果被30覆盖,故最后只有30,15输出。

以上demo 出自Android RxJava使用介绍(三) RxJava的操作符,最后总结下map,flatmap,contactmap,switchmap的使用场景区别:map用于不需要通过操作符就可以完成的转换,flatmap用于需要通过操作符才可以转换的操作,但是输出结果可能会是乱序,contactmap的作用在flatmap的基础上保证输出结果按照输入顺序输出,switchmap的作用在flatmap的基础上,对输出结果若同时发生,只会保证最新结果而放弃旧数据。

Scan操作符

作用:连续地对数据序列的每一项应用一个函数,然后连续发射结果

    Integer numbers[]={1,2,3,4,5,};
    Observable observable=Observable.from(numbers);
    subscription=observable.scan(new Func2<Integer,Integer,Integer>() {
                @Override
                public Integer call(Integer sum, Integer item) {
                    System.out.println(" sum: "+sum+"  item: "+item);
                    return sum+item;
                }
            })
            .subscribe(new Action1() {
                @Override
                public void call(Object o) {
                    System.out.println(" number: "+o);
                }
            });
    SubscriptionManager.setSubscription(subscription);

输出结果:

例子说明:这里要注意的是变量sum等于输入数相加,item为某项输入,例如:现在输入的是3,即item为3,sum则为1和2相加的结果,最后返回的是3+3等6,下一步输入item为4,则sum为6,接下来返回的便是6+4的结果。

groupBy操作符

作用:可以对输入的数据根据自定义类型分组

Observable.create(new Observable.OnSubscribe<Integer>() {
        @Override
        public void call(Subscriber<? super Integer> subscriber) {
            for(int i=0;i<6;i++){
                int number=random.nextInt(10);
                System.out.println("key: " + number);
                subscriber.onNext(number);
            }
        }
    }).groupBy(new Func1<Integer, String>() {
        @Override
        public String call(Integer value) {
            return value % 2 == 0 ? "偶数" : "奇数";
        }
    }).subscribe(new Action1<GroupedObservable<String, Integer>>() {
        @Override
        public void call(final GroupedObservable<String, Integer> stringIntegerGroupedObservable) {
            stringIntegerGroupedObservable.subscribe(new Action1<Integer>() {
                @Override
                public void call(Integer integer) {
                    System.out.println("key:" + stringIntegerGroupedObservable.getKey() +", value:" + integer);
                }
            });
        }
    });

输出结果:

例子说明:输入六个随机数8,1,2,8,7,8,结果我原以为数据会先输出偶数项,再输出奇数项,但是结果却是输出数据的顺序和输入一致,但是通过GroupedObservable.getkey 方法可以获取数据所属分类。另外这里需要注意的是:groupBy将原始Observable分解为一个发射多个GroupedObservable的Observable,一旦有订阅,每个GroupedObservable就开始缓存数据。因此,如果你忽略这些GroupedObservable中的任何一个,这个缓存可能形成一个潜在的内存泄露。因此,如果你不想观察,也不要忽略GroupedObservable。你应该使用像take(0)这样会丢弃自己的缓存的操作符。

Buffer操作符

作用:定期收集Observable的数据放进一个数据包裹,然后发射这些数据包裹,而不是一次发射一个值。

     Observable.create(new Observable.OnSubscribe<String>() {

        @Override
        public void call(Subscriber<? super String> subscriber) {
                final String[] names = {"小-", "小二", "小三", "小四", "小五"};
                Random random = new Random();
                if(subscriber.isUnsubscribed()){
                    return;
                }
                do {
                    String name = names[random.nextInt(names.length)];
                    subscriber.onNext(name);
                try {
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
                } while (true);
        }
    }).subscribeOn(Schedulers.io()).buffer(2,TimeUnit.SECONDS).subscribe(new Action1<List<String>>() {
        @Override
        public void call(List<String> strings) {
            System.out.println("开始两秒点一次名字...");
            for (String name:strings) {
                System.out.println("name: "+name);
            }
        }
    });

输出结果:

例子说明:create操作符里面一直在做每隔1秒就发送一个随机名字的操作,通过buffer操作符可以实现每隔2秒输出一组名字。

Window操作符

作用:和buffer类似作用类似,但是输出的是Observable而不是具体数据

Observable.interval(1, TimeUnit.SECONDS).take(10).
            window(2,TimeUnit.SECONDS).subscribe(new Action1<Observable<Long>>() {
        @Override
        public void call(Observable<Long> longObservable) {

            System.out.println("每隔两秒打印.....");
            longObservable.subscribe(new Action1<Long>() {
                @Override
                public void call(Long aLong) {
                    System.out.println("currentNumber: "+aLong);
                }
            });
        }
    });

输出结果:

例子说明:interval操作符表示按照顺序和预期时间输出一个0-n的数列,例如:0,1,2...n, take操作符表示截取前n个结果集,在例子中就是截取interval操作符输出的0-9共10个数,** window操作符作用和buffer差不多,不同的是buffer输出具体的数值,但是Window输出的Observable,需要再进一步订阅才能输出具体数值**。

Cast操作符

作用:对数据进行强转类型

但是实际使用中本人发现仅仅能用于对输入数据的类型判断是否符合预期

    String[] strs=new String[]{"1","2","3","4","5"};
    subscription=Observable.from(strs).observeOn(Schedulers.io()).cast(Integer.class).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer integer) {
            System.out.println("integer: " + integer);
        }
    }, new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {
            throwable.printStackTrace();
        }
    });

输出结果:

例子说明:输入类型正确则输出源数据,如果输入数据某项内容类型不正确,则报错。

以上便是变换操作符的主要内容了。有啥问题欢迎大家留言交流下😊,下篇文章再说说过滤操作符欢迎关注。

附录:
文章demo

参考:
ReactiveX/RxJava文档中文版

推荐阅读更多精彩内容