RxJava操作符

最新推荐文章于 2023-08-25 19:51:44 发布
最新推荐文章于 2023-08-25 19:51:44 发布
阅读量183 收藏
点赞数 1
分类专栏： RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdg745979749/article/details/89890208
版权

学习新的东西还是要写下博客，不然太容易忘记了。。。

RxJava的操作符

操作符分为以下几类

创建操作符
interval创建一个按固定时间间隔发送整数序列的Observable
range创建发送指定范围的整型序列的Observable
repeat创建一个N次重复发射特定数据的Observable

示例代码如下：

package com.magic.rxjava;

import android.util.Log;

import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.Consumer;

/***
 *@author Create By Magic
 *@date 2019/5/6
 **/
public class RxJavaCreateOperateSymbol extends RxJava {
    private static final String TAG = "RxJavaCreateOperateSymb";


    /**
     * 创建一个按固定时间间隔发送整数序列的Observable
     * 结果会从0开始打印，每隔1s加1
     */
    public void interval() {
        Disposable disposable = Observable.interval(1, TimeUnit.SECONDS)
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {
                        Log.i(TAG, "accept: " + aLong);
                    }
                });
    }


    /**
     * 创建发送指定范围的整型序列的Observable
     * 第一个参数为起始值，第二个参数值为数量
     */
    public void range(){
        Disposable disposable = Observable.range(0, 88)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: " + integer);
                    }
                });
    }


    /**
     * repeat 一般和range连用
     * 表示重复某个range范围内的次数
     */
    public void repeat(){
        Disposable disposable = Observable.range(0,5).repeat(10)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.i(TAG, "accept: " + integer);
                    }
                });
    }
}
变换操作符
map指定一个Func对象将Observable转换成一个新的Observable发射出去
flapMap

将Observable发送的数据集合转换成Observable集合发射出去

注意：flapMap不保证发射的顺序

cast强制将Observable发送的所有数据类型转换为指定类型
concatMap

将Observable发送的数据集合转换成Observable集合发射出去

注意：concatMap保证发射的顺序

flatMapIterable可以将数据包装成Iterable
buffer將源Observable变换成一个新的Observable，每次发射一组列表值而不是一个一个发
groupBy用于分组元素

 

package com.magic.rxjava;

import android.util.Log;

import com.bean.School;
import com.bean.Student;
import com.bean.Teacher;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import io.reactivex.functions.BiFunction;
import io.reactivex.functions.Consumer;
import io.reactivex.functions.Function;
import io.reactivex.functions.Predicate;
import io.reactivex.observables.GroupedObservable;
import io.reactivex.schedulers.Schedulers;

/***
 *@author Create By Magic
 *@date 2019/5/4
 **/
public class RxJavaOperateSymbol {
    private static final String TAG = "RxJavaOperateSymbol";

    private Student student1 = new Student(1, "1");
    private Student student2 = new Student(2, "2");
    private Student student3 = new Student(2, "3");
    private Student student4 = new Student(2, "4");
    private Student student5 = new Student(3, "5");
    private Student student6 = new Student(1, "6");

    private Teacher teacher1 = new Teacher("小学1", "王老师");
    private Teacher teacher2 = new Teacher("小学2", "李老师");
    private Teacher teacher3 = new Teacher("小学3", "刘老师");

    Observable<Student> mStudentObservable = Observable.create(new ObservableOnSubscribe<Student>() {
        @Override
        public void subscribe(ObservableEmitter<Student> emitter) throws Exception {
            emitter.onNext(student1);
            emitter.onNext(student2);
            emitter.onNext(student3);
            emitter.onNext(student4);
            emitter.onNext(student5);
            emitter.onNext(student6);
        }
    });

    Observable<Teacher> mTeacherObservable = Observable.create(new ObservableOnSubscribe<Teacher>() {
        @Override
        public void subscribe(ObservableEmitter<Teacher> emitter) throws Exception {
            emitter.onNext(teacher1);
            Log.i(TAG, "subscribe: emitter  teacher 1");
            emitter.onNext(teacher2);
            Log.i(TAG, "subscribe: emitter  teacher 2");
            emitter.onNext(teacher3);
            Log.i(TAG, "subscribe: emitter  teacher 3");
        }
    });

    Observer<School> mSchoolObservable = new Observer<School>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(School school) {
            Log.i(TAG, "[School] onNext: " + school);
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    };

    Observer<Student> mStudentObserver = new Observer<Student>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(Student student) {
            Log.i(TAG, "onNext: " + student);
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onComplete() {

        }
    };


    /**
     * map操作符用户转换类型、或者做一些操作
     */
    public void map() {
        Function<Student, Student> mapFunction = new Function<Student, Student>() {
            @Override
            public Student apply(Student student) throws Exception {
                student.setAge(student.getAge() + 1);
                student.setName(student.getName() + "_change");
                return student;
            }
        };

        mStudentObservable.map(mapFunction).subscribe(mStudentObserver);
    }


    /**
     * flapMap 将数据集合变成Observerble集合
     * flapMap是无序的
     */
    public void flapMap() {

        Function flatFunction = new Function<Student, ObservableSource<Student>>() {

            @Override
            public ObservableSource<Student> apply(Student student) throws Exception {
                List<Student> studentList = new ArrayList<>();
                studentList.add(student1);
                studentList.add(student2);
                studentList.add(student3);
                //后面增加100ms延迟是为了显示flapMap是无序的
                return Observable.fromIterable(studentList).delay(100, TimeUnit.MILLISECONDS);
            }
        };

        mStudentObservable.flatMap(flatFunction).subscribe(mStudentObserver);
    }


    public void cast() {
        Observable.just(1, 2, 3, 4, 5).cast(Integer.class)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer s) throws Exception {
                        Log.i(TAG, "accept: " + s);
                    }
                });
    }


    /**
     * concatMap 将数据集合变成Observerble集合
     * concatMap 是有序的
     */
    public void concatMap() {
        Function fconcatMapFunction = new Function<Student, ObservableSource<Student>>() {

            @Override
            public ObservableSource<Student> apply(Student student) throws Exception {
                List<Student> studentList = new ArrayList<>();
                studentList.add(student1);
                studentList.add(student2);
                studentList.add(student3);
                //后面增加100ms延迟是为了显示flapMap是无序的
                return Observable.fromIterable(studentList).delay(100, TimeUnit.MILLISECONDS);
            }
        };
        mStudentObservable.concatMap(fconcatMapFunction).subscribe(mStudentObserver);
    }


    /**
     * zip 用于在发送的时候合并多个Observable
     * 注意由于两个Observable都是在主线程中进行所以需要分别指定其运行的线程
     */
    public void zip() {
        BiFunction biFunction = new BiFunction<Student, Teacher, School>() {
            @Override
            public School apply(Student student, Teacher teacher) throws Exception {
                return new School(student, teacher);
            }
        };
        Observable<Student> studentObservable = mStudentObservable
                .subscribeOn(Schedulers.newThread());
        Observable<Teacher> teacherObservable = mTeacherObservable
                .subscribeOn(Schedulers.newThread());
        Observable.zip(studentObservable, teacherObservable, biFunction)
                .subscribe(mSchoolObservable);
    }


    /**
     * 过滤器，当符合条件下游才进行接收
     */
    public void filter() {
        mStudentObservable.delay(1, TimeUnit.SECONDS)
                .filter(new Predicate<Student>() {
                    @Override
                    public boolean test(Student student) throws Exception {
                        //过滤学生年龄大于12的学生
                        return student.getAge() > 12;
                    }
                })
                .subscribe(mStudentObserver);
    }


    /**
     * sample 关键字用于定时去取离源最近的数据
     */
    public void sample() {
        mStudentObservable.sample(1, TimeUnit.SECONDS)
                .subscribe(mStudentObserver);
    }

    public void flapMapIterable() {
        mStudentObservable.flatMapIterable(new Function<Student, Iterable<Student>>() {
            @Override
            public Iterable<Student> apply(Student student) throws Exception {
                List<Student> studentList = new ArrayList<>();
                student1.setAge(1);
                studentList.add(student1);
                return studentList;
            }
        }).subscribe(new Consumer<Student>() {
            @Override
            public void accept(Student student) throws Exception {
                Log.i(TAG, "accept: " + student);
            }
        });
    }

    public void groupBy() {
        mStudentObservable.groupBy(new Function<Student, Integer>() {
            @Override
            public Integer apply(Student student) throws Exception {
                return student.getAge() == 2?0:1;
            }
        }).subscribe(new Consumer<GroupedObservable<Integer, Student>>() {
            @Override
            public void accept(final GroupedObservable<Integer, Student> integerStudentGroupedObservable) throws Exception {
                integerStudentGroupedObservable.subscribe(new Consumer<Student>() {
                    @Override
                    public void accept(Student student) throws Exception {
                        Log.i(TAG, "accept: "+student+" [age]"+integerStudentGroupedObservable.getKey());
                    }
                });
            }
        });
    }

    public void buffer() {
        mStudentObservable.buffer(2).subscribe(new Consumer<List<Student>>() {
            @Override
            public void accept(List<Student> students) throws Exception {
                for (int i = 0; i < students.size(); i++) {
                    Log.i(TAG, "accept: " + students.get(i));
                }
                Log.i(TAG, "accept: ==========");
            }
        });
    }


    private void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

 

MagicGGGGGGGGGGG
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava 操作符使用
03-27
RxJava 操作符、线程调度 观察者 RxJava是一种事件驱动的基于异步数据流的编程模式，整个数据流就像一条河流，它可以被观测（监听），过滤，操控或者与其他数据流合并为一条新的数据流。三要素Rxjava原理 基于 一种...
RxJava操作符大全
热门推荐
maplejaw的博客
09-01 3万+
再也不用担心记不住RxJava中的操作符了，RxJava操作符大全，需要用时Ctrl+F一下，还有使用例子哦。
RxJava 操作符
最新发布
u010498248的博客
08-25 547
在 RxJava 中，一个实现了 observer 接口的对象可以订阅 observable 类的实例。订阅者对 observable 发射的任何数据或者数据序列做出响应。这种模式简化了并发操作，因为它不需要阻塞等待 observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 observable 的通知。RxJava 提供了一套异步编程的 API ，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁。
Rxjava操作符
小耶耶的博客
07-08 222
Rxjava操作符汇总 操作符类别 操作符名称 功能描述 创建 操作符 基本创建 create 最基本的创建方式 快速创建 just 直接发送传入的值 fromArray 遍历发送传入的数组 fromlterable 遍历发送传入的List集合 never 不发送任何事件 empty 仅发送Complete事件 error 仅发送E
RxJava 操作符 图片
03-31
**RxJava 操作符详解** RxJava 是一个用于处理异步数据流的库，它引入了反应式编程的概念，使得事件处理变得更加灵活和易于管理。在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成...
Android + Rxjava + Rxjava操作符
04-23
1：Rxjava创建操作符：（create() ， just()，fromArray()，fromIterable() ，time() , interval()） 2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , ...
RxJavaApp：学习RxJava操作符的APP，再加上RxJava2.x介绍
01-31
学习RxJava操作符的APP 全新升级，更漂亮，更耐看，已加入RxJava2.x介绍自行编译 展示： 下载地址 自行编译 说明： 徽标徽标网络 app中用到的数据来自： : 介绍的操作符并非全部操作符，大都是我们常用的，想要看...
RxJava入门：常用操作符详解
"本文将介绍RxJava入门中常用的操作符，包括Observable的创建，特别是from()和just()两个方法的使用。" RxJava是一种用于处理异步数据流的库，它引入了响应式编程的概念，使得处理事件和数据变得更加简洁高效。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值