RxJava操作符

最新推荐文章于 2023-08-25 19:51:44 发布
原创 最新推荐文章于 2023-08-25 19:51:44 发布 · 226 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

博客主要围绕RxJava的操作符展开，提到操作符分为几类，并给出了示例代码，帮助学习和记忆RxJava操作符相关知识。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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

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();
        }
    }

}

 

12、RxJava 操作符与并发编程详解
view3的博客
07-15 19
本文详细介绍了 RxJava 的常用操作符，包括数据转换、组合、过滤、条件判断以及数学聚合操作符，并结合示例代码展示了它们的实际用法。同时深入探讨了 RxJava 中的并发编程机制，包括调度器（Scheduler）、多线程操作符（subscribeOn 和 observeOn）以及如何通过 flatMap 减少延迟。最后总结了操作符与并发控制在响应式编程中的重要性，并提供了典型的数据处理流程图。
RxJava操作符大全
热门推荐
maplejaw的博客
09-01 3万+
再也不用担心记不住RxJava中的操作符了，RxJava操作符大全，需要用时Ctrl+F一下，还有使用例子哦。
RxJava 操作符
u010498248的博客
08-25 653
在 RxJava 中，一个实现了 observer 接口的对象可以订阅 observable 类的实例。订阅者对 observable 发射的任何数据或者数据序列做出响应。这种模式简化了并发操作，因为它不需要阻塞等待 observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 observable 的通知。RxJava 提供了一套异步编程的 API ，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁。
Rxjava操作符
yjs1129580545的专栏
02-09 297
1、map(）操作符（一对一的转化）Observable.just("Hello") .map(new Func1<String, String>() { @Override public String call(String s) { re
RxJava 操作符使用
最新发布
03-27
RxJava 操作符、线程调度 观察者 RxJava是一种事件驱动的基于异步数据流的编程模式，整个数据流就像一条河流，它可以被观测（监听），过滤，操控或者与其他数据流合并为一条新的数据流。三要素Rxjava原理 基于 一种...
Android + Rxjava + Rxjava操作符
04-23
1：Rxjava创建操作符：（create() ， just()，fromArray()，fromIterable() ，time() , interval()） 2: 转换操作符：（map() , flatMap() ） 3: 合并操作符：（merge() , collect()） 4: 功能操作符：（delay() , ...
RxJava 操作符 图片
03-31
**RxJava 操作符详解** RxJava 是一个用于处理异步数据流的库，它引入了反应式编程的概念，使得事件处理变得更加灵活和易于管理。在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成...
RxJava操作符在Android中的应用示例
本知识点将围绕RxJava操作符的使用进行讲解，并提供一些简单示例。 ### 知识点一：什么是RxJava操作符 在RxJava中，操作符是用于处理Observable发出的数据流的强大工具。它们允许你将一系列的转换应用于Observable...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值