RxJava的操作符

最新推荐文章于 2024-04-14 18:01:38 发布
最新推荐文章于 2024-04-14 18:01:38 发布
阅读量221 收藏
点赞数 1
分类专栏： Android studio 文章标签： RxJava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42179105/article/details/84800814
版权

RxJava中提供了大量不同种类，不同场景的Operators(操作符)，RxJava的强大性就来自于它所定义的操作符。主要分类：

  • 创建操作：用于创建Observable的操作符；
  • 变换操作：这些操作符可用于对Observable发射的数据进行变换；
  • 过滤操作：这些操作符用于从Observable发射的数据中进行选择；
  • 组合操作：组合操作符用于将多个Observable组合成一个单一的Observable；
  • 异常处理：这些操作符用于从错误通知中恢复；
  • 辅助操作：一组用于处理Observable的操作符；

其实我们创建Observable的create()，from()，just()等方法，都属于创建操作符。那么，让我们通过代码，来看看各种操作符的实现。

1.创建操作

defer( ) — 只有当订阅者订阅才创建Observable；为每个订阅创建一个新的Observable

Observable.defer(new Func0<Observable<Object>>() {
    @Override
    public Observable<Object> call() {
        //创建并返回新的Observable，
        return null;
    }
});

repeat( ) — 创建一个重复发射指定数据或数据序列的Observable

Observable.just(1).repeat(3).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        Log.d("RxJava", String.valueOf(integer));
    }
});

结果：将数字1，重复发射3次

11-06 15:05:39.610 7636-7636/? D/RxJava: 1
11-06 15:05:39.611 7636-7636/? D/RxJava: 1
11-06 15:05:39.611 7636-7636/? D/RxJava: 1

range( ) — 创建一个发射指定范围的整数序列的Observable

Observable.range(1,4).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        Log.d("RxJava", String.valueOf(integer));
    }
});

结果：发射1-4的整数

11-06 15:12:02.076 19930-19930/keye.com.rxjavaobserver D/RxJava: 1
11-06 15:12:02.076 19930-19930/keye.com.rxjavaobserver D/RxJava: 2
11-06 15:12:02.076 19930-19930/keye.com.rxjavaobserver D/RxJava: 3
11-06 15:12:02.076 19930-19930/keye.com.rxjavaobserver D/RxJava: 4

 

interval( ) — 创建一个按照给定的时间间隔发射整数序列的Observable

Observable.interval(1, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
    @Override
    public void call(Long i) {
        Log.d("RxJava", String.valueOf(i));
    }
});

结果：每个1秒，发射一个整数序列中的数

11-06 15:16:58.648 29492-29524/keye.com.rxjavaobserver D/RxJava: 1
11-06 15:16:59.684 29492-29524/keye.com.rxjavaobserver D/RxJava: 2
11-06 15:17:00.688 29492-29524/keye.com.rxjavaobserver D/RxJava: 3
11-06 15:17:01.683 29492-29524/keye.com.rxjavaobserver D/RxJava: 4
11-06 15:17:02.689 29492-29524/keye.com.rxjavaobserver D/RxJava: 5
11-06 15:17:03.688 29492-29524/keye.com.rxjavaobserver D/RxJava: 6
11-06 15:17:04.685 29492-29524/keye.com.rxjavaobserver D/RxJava: 7
11-06 15:17:05.683 29492-29524/keye.com.rxjavaobserver D/RxJava: 8
11-06 15:17:06.683 29492-29524/keye.com.rxjavaobserver D/RxJava: 9

timer( ) — 创建一个在给定的延时之后发射单个数据的Observable

Observable.timer(3, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
    @Override
    public void call(Long i) {
        Log.d("RxJava", i);
    }
});

结果：3秒后，发射了一个包含数字0的Observable

11-06 15:22:57 /keye.com.rxjavaobserver D/RxJava: 0

empty( ) — 创建一个什么都不做直接通知完成的Observable

Observable.empty().subscribe(new Subscriber<Object>() {
    @Override
    public void onCompleted() {
        Log.d("RxJava", "发送了一个空的的Observable");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(Object o) {

    }
});

结果：发送了一个空的Observable，直接调用了onCompleted()方法

11-06 15:22:57 D/RxJava: 发送了一个空的的Observable

error( ) — 创建一个什么都不做直接通知错误的Observable

Observable.empty().subscribe(new Subscriber<Object>() {
    @Override
    public void onCompleted() {
       
    }

    @Override
    public void onError(Throwable e) {
       Log.d("RxJava", "发送了一个空的的Observable");
    }

    @Override
    public void onNext(Object o) {

    }
});

结果：发送了一个空的Observable，直接调用了onError()方法

11-06 15:22:57 D/RxJava: 发送了一个空的的Observable

 

2.变换操作

scan( ) — 对Observable发射的每一项数据应用一个函数，然后按顺序依次发射每一个值

Observable.just(1, 2, 3)
        .scan(new Func2<Integer, Integer, Integer>() {
            @Override
            public Integer call(Integer integer, Integer integer2) {
                //自定义函数
                return integer + integer2;
            }
        })
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d("RxJava", String.valueOf(integer));
            }
        });

结果：将自定义函数应用于数据序列，并将这个函数的结果作为函数下一次的参数1使用，1+0=1，1+2=3 ，3+3=6

11-06 02:54:43.040 25433-25433/keye.com.rxjavaobserver D/RxJava: 1
11-06 02:54:43.040 25433-25433/keye.com.rxjavaobserver D/RxJava: 3
11-06 02:54:43.040 25433-25433/keye.com.rxjavaobserver D/RxJava: 6

groupBy( ) — 将Observable分拆为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据

Observable.just(1, 2, 3, 4)
        .groupBy(new Func1<Integer, Integer>() {
            @Override
            public Integer call(Integer integer) {
                //这里返回的结果为key
                return integer + 1;
            }
        })
        .subscribe(new Action1<GroupedObservable<Integer, Integer>>() {
            @Override
            public void call(GroupedObservable<Integer, Integer> groupedObservable) {

                groupedObservable.subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d("RxJava", "key:" + groupedObservable.getKey() + ",value:" + integer);
                    }
                });
            }
        });

结果：在第一个func1函数中，设置key，最后生成一个Observable集合，并把每一个groupedObservable，并依次发射出去

 3162-3162/keye.com.rxjavaobserver D/RxJava: key:2,value:1
 3162-3162/keye.com.rxjavaobserver D/RxJava: key:3,value:2
 3162-3162/keye.com.rxjavaobserver D/RxJava: key:4,value:3
 3162-3162/keye.com.rxjavaobserver D/RxJava: key:5,value:4

buffer( ) — 它定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个

Observable.just(1, 2, 3, 4,5,6,7)
          .buffer(2, 1)
          .subscribe(new Action1<List<Integer>>() {
              @Override
              public void call(List<Integer> integers) {
                Log.d("RxJava", integers + "");
              }
});

结果：buffer()有两个参数count和skip，count指定List的大小，skip指定每次发射一个List需要跳过几个数；buffer(2, 1)：每组2个数，每次跳过1个数，结果如下：

keye.com.rxjavaobserver D/RxJava: [1, 2]
keye.com.rxjavaobserver D/RxJava: [4, 5]
keye.com.rxjavaobserver D/RxJava: [7]

window( ) — 定期将来自Observable的数据分拆成一些Observable窗口，然后发射这些窗口，而不是每次发射一项

Observable.just(1, 2, 3, 4, 5, 6, 7)
          .window(2, 2)
          .subscribe(new Action1<Observable<Integer>>() {
              @Override
              public void call(Observable<Integer> observable) {
                  Log.d("RxJava", "window" );
                  observable.subscribe(new Action1<Integer>() {
                      @Override
                      public void call(Integer integer) {
                          Log.d("RxJava", integer + "");
                      }
                  });
              }
});

结果：window()操作符和buffer()类似，都是缓存一段数据集合，再打包发射出去

11-06 03:30:29.198 25883-25883/? D/RxJava: window
11-06 03:30:29.198 25883-25883/? D/RxJava: 1
11-06 03:30:29.198 25883-25883/? D/RxJava: 2
11-06 03:30:29.198 25883-25883/? D/RxJava: window
11-06 03:30:29.198 25883-25883/? D/RxJava: 3
11-06 03:30:29.198 25883-25883/? D/RxJava: 4
11-06 03:30:29.198 25883-25883/? D/RxJava: window
11-06 03:30:29.198 25883-25883/? D/RxJava: 5
11-06 03:30:29.199 25883-25883/? D/RxJava: 6
11-06 03:30:29.199 25883-25883/? D/RxJava: window
11-06 03:30:29.199 25883-25883/? D/RxJava: 7

3.过滤操作

filter( ) — 过滤数据

Observable.just(1, 2, 3, 4, 5, 6)
        .filter(new Func1<Integer, Boolean>() {
            @Override
            public Boolean call(Integer integer) {
                //从数组中，筛选偶数
                return integer % 2 == 0;
            }
        }).subscribe(new Action1<Integer>() {
            @Override
             public void call(Integer i) {
                Log.d("RxJava", String.valueOf(i));
        }
});

结果：

11-06 03:42:04.747 4213-4213/? D/RxJava: 2
11-06 03:42:04.747 4213-4213/? D/RxJava: 4
11-06 03:42:04.747 4213-4213/? D/RxJava: 6

takeLast( ) — 只发射最后的N项数据

Observable.just(1, 2, 3, 4, 5, 6)
        .takeLast(3)  //取最后3项数据
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer i) {
                Log.d("RxJava", String.valueOf(i));
            }
        });

结果：

11-06 03:44:18.307 6379-6379/keye.com.rxjavaobserver D/RxJava: 4
11-06 03:44:18.307 6379-6379/keye.com.rxjavaobserver D/RxJava: 5
11-06 03:44:18.307 6379-6379/keye.com.rxjavaobserver D/RxJava: 6

last( ) — 只发射最后的一项数据

Observable.just(1, 2, 3, 4, 5, 6)
        .last()
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer i) {
                Log.d("RxJava", String.valueOf(i));
            }
        });

结果：

11-06 03:49:46.710 6582-6582/? D/RxJava: 6

skip( ) — 跳过开始的N项数据

Observable.just(1, 2, 3, 4, 5, 6)
        .skip(3)
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer i) {
                Log.d("RxJava", String.valueOf(i));
            }
        });

结果：

11-06 03:49:46.710 6582-6582/? D/RxJava: 4
11-06 03:49:46.710 6582-6582/? D/RxJava: 5
11-06 03:49:46.710 6582-6582/? D/RxJava: 6

take( ) — 只发射开始的N项数据

Observable.just(1, 2, 3, 4, 5, 6)
        .take(3)
        .subscribe(i -> {
            Log.d("RxJava", String.valueOf(i));
        });

结果：

11-06 03:49:46.710 6582-6582/? D/RxJava: 1
11-06 03:49:46.710 6582-6582/? D/RxJava: 2
11-06 03:49:46.710 6582-6582/? D/RxJava: 3

first( ) and takeFirst( ) — 只发射第一项数据，或者满足某种条件的第一项数据

Observable.just(1, 2, 3, 4, 5, 6)
        .first()
        .subscribe(i -> {
            Log.d("RxJava", String.valueOf(i));
        });

结果：

11-06 03:49:46.710 6582-6582/? D/RxJava: 1

elementAt( ) — 发射第N项数据

Observable.just(1, 2, 3, 4, 5, 6)
        .elementAt(3)
        .subscribe(i -> {
            Log.d("RxJava", String.valueOf(i));
        });

结果：

11-06 03:49:46.710 6582-6582/? D/RxJava: 4

sample( ) or throttleLast( ) — 定期发射Observable最近的数据

Observable.interval(1,TimeUnit.SECONDS)
        .sample(4, TimeUnit.SECONDS)
        .subscribe(i -> {
            Log.d("RxJava", String.valueOf(i));
        });

结果：interval()每隔一秒发送整数序列，sample()每隔4秒，获取Observable的数据，结果如下：

-16618/keye.com.rxjavaobserver D/RxJava: 3
-16618/keye.com.rxjavaobserver D/RxJava: 6
-16618/keye.com.rxjavaobserver D/RxJava: 10
-16618/keye.com.rxjavaobserver D/RxJava: 14
-16618/keye.com.rxjavaobserver D/RxJava: 18
-16618/keye.com.rxjavaobserver D/RxJava: 22

debounce( ) — 只有当Observable在指定的时间后还没有发射数据时，才发射一个数据

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> subscriber) {
        try {
            for (int i = 1; i < 10; i++) {
                subscriber.onNext(i);
                Thread.sleep(i * 1000); //每次发送，延迟i*1秒
            }
            subscriber.onCompleted();
        } catch (Exception e) {
            subscriber.onError(e);
        }
    }
})
        .subscribeOn(Schedulers.newThread())
        .debounce(3000, TimeUnit.MILLISECONDS) //3秒没有数据，则发送
        .subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Log.d("RxJava", String.valueOf(integer));
            }
        });

结果：前3个数延迟短，没有触发debounce()操作符，第4个数延迟3秒，debounce()生效

30534-30550/keye.com.rxjavaobserver D/RxJava: 4
30534-30550/keye.com.rxjavaobserver D/RxJava: 5
30534-30550/keye.com.rxjavaobserver D/RxJava: 6
30534-30550/keye.com.rxjavaobserver D/RxJava: 7
30534-30550/keye.com.rxjavaobserver D/RxJava: 8

distinct( ) — 过滤掉重复数据

Observable.just(1, 2, 1, 4, 1, 6)
        .distinct()
        .subscribe(i -> {
            Log.d("RxJava", String.valueOf(i));
        });

结果：

11-06 04:38:49.987 19504-19504/keye.com.rxjavaobserver D/RxJava: 1
11-06 04:38:49.987 19504-19504/keye.com.rxjavaobserver D/RxJava: 2
11-06 04:38:49.987 19504-19504/keye.com.rxjavaobserver D/RxJava: 4
11-06 04:38:49.988 19504-19504/keye.com.rxjavaobserver D/RxJava: 6

ofType( ) — 只发射指定类型的数据

Observable.just(1, "2", 3, "4", 5, 6)
        .ofType(Integer.class)
        .subscribe(i -> {
            Log.d("RxJava", String.valueOf(i));
        });

结果：

11-06 04:44:28.321 25785-25785/keye.com.rxjavaobserver D/RxJava: 1
11-06 04:44:28.321 25785-25785/keye.com.rxjavaobserver D/RxJava: 3
11-06 04:44:28.321 25785-25785/keye.com.rxjavaobserver D/RxJava: 5
11-06 04:44:28.321 25785-25785/keye.com.rxjavaobserver D/RxJava: 6
我是永恒
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava操作符
07-01
RxJava操作符的简单使用示例，不是全部，还有很多后边慢慢学习了会补上
RxJava 操作符使用
03-27
RxJava 操作符、线程调度 观察者 RxJava是一种事件驱动的基于异步数据流的编程模式，整个数据流就像一条河流，它可以被观测（监听），过滤，操控或者与其他数据流合并为一条新的数据流。三要素Rxjava原理 基于 一种...
RxJava操作符汇总
chuyouyinghe的专栏
02-07 5758
RxJava操作符包含的操作符类型有如下几种： 1、创建操作符 ：创建被观察者（Observable）对象&发送事件 转自：RxJava操作符汇总_zengke的博客-CSDN博客_rxjava操作符 https://blog.csdn.net/zengke1993/article/details/80388510 ...
RxJava操作符入门
肇秋贰拾捌的博客
05-16 915
【代码】RxJava操作符入门。
Android RxJava： 这是一份全面的 操作符 使用汇总 （含详细实例讲解）(1)
最新发布
2401_84121702的博客
04-14 857
针对于上面的问题，我总结出了互联网公司Android程序员面试涉及到的绝大部分面试题及答案，并整理做成了文档，以及系统的进阶学习视频资料。（包括Java在Android开发中应用、APP框架知识体系、高级UI、全方位性能调优，NDK开发，音视频技术，人工智能技术，跨平台技术等技术资料），希望能帮助到你面试前的复习，且找到一个好的工作，也节省大家在网上搜索资料的时间来学习。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
Rxjava3 全新详解及常用操作符
ezconn的博客
10-15 2061
RxJava 是一个基于 Java 的响应式编程库，用于处理异步事件流和数据流。它是由 Netflix 开发并开源，现在广泛用于 Android 和 Java 后端开发。RxJava 提供了一种用于组合和处理异步数据的丰富工具集，它的核心思想是将数据流视为一系列事件，以响应事件的方式进行处理。RxJava 提供了丰富的操作符，用于处理和转换数据流。这些操作符可以帮助你执行各种操作，包括过滤、映射、合并、变换等，以便更好地处理异步数据流。
RxJava 操作符
u010498248的博客
08-25 475
在 RxJava 中，一个实现了 observer 接口的对象可以订阅 observable 类的实例。订阅者对 observable 发射的任何数据或者数据序列做出响应。这种模式简化了并发操作，因为它不需要阻塞等待 observable 发射数据，而是创建了一个处于待命状态的观察者哨兵，哨兵在未来某个时刻响应 observable 的通知。RxJava 提供了一套异步编程的 API ，并且支持链式调用，所以使用 RxJava 编写的代码的逻辑会非常简洁。
Android-Rxjava 常用操作符
风的轨迹
04-02 4670
Rxjava的优势 提高工作效率 能优雅的解决复杂的业务场景 1.Rxjava原理 RxJava 的原理就是创建一个 Observable 对象来干活，然后使用各种操作符建立起来的链式操作，就如同流水线一样，把你想要处理的数据一步一步地加工成你想要的成品，然后发射给 Subscriber 处理。 2.使用Rxjava需要添加的依赖 implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' implementation 'io.reactivex.
RxJava 操作符 图片
03-31
RxJava 操作符图片,, 根据Flowable.java 上面的http链接下载的图片,
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常用操作符
05-17
rxjava入门常用操作符
RxJava（一）创建操作符
牛永志的专栏
09-18 475
RxJava创建操作符
Rxjava操作符使用
duncan891101的专栏
08-11 390
一、简介 Rxjava是基于事件流调用的方式来实现异步的库，它最大的特点就是哪怕逻辑很复杂，依然能保持简洁和优雅。异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。其原理是一种扩展的观察者模式。这里有四个角色： 被观察者（Observable） ==> 产生事件 观察者（Observer） ==> 接收事件，并给出响应动作 订阅（Subscribe） ==> 连接被观察者和观察者 事件（Event） ==> 被观察者 & 观察
RxJava2.0（三）强大的操作符
m0_49508485的博客
09-22 809
上一节讲解了线程调度, 并且举了两个实际中的例子, 其中有一个登录的例子, 不知大家有没有想过这么一个问题, 如果是一个新用户, 必须先注册, 等注册成功之后再自动登录该怎么做呢.很明显, 这是一个嵌套的网络请求, 首先需要去请求注册, 待注册成功回调了再去请求登录的接口..subscribeOn(Schedulers.io()) //在IO线程进行网络请求.observeOn(AndroidSchedulers.mainThread()) //回到主线程去处理请求结果@Override。
Rxjava操作符
小耶耶的博客
07-08 216
Rxjava操作符汇总 操作符类别 操作符名称 功能描述 创建 操作符 基本创建 create 最基本的创建方式 快速创建 just 直接发送传入的值 fromArray 遍历发送传入的数组 fromlterable 遍历发送传入的List集合 never 不发送任何事件 empty 仅发送Complete事件 error 仅发送E
RxJava操作符（一）Creating Observables
lizubing1992的专栏
03-02 778
RxJava只是ReactiveX(Reactive Extensions)的一种java实现, ReactiveX是一种响应式扩展框架，有很多种实现，如RxAndroid, RxJS, RxSwift, RxRuby等等。RX采用一种类似于观察者的形式来实现各种功能，跟我们一般的写代码思路差别较大。刚开始接触可能会觉得难以理解，但是一旦掌握地话就会体会到其强大之处。其原理就是创建一个Observ
RxJava精简教程
01-21
介绍RxJava的基本用法
Android RxJava同步操作
12-26
这两种方法都是使用`just`操作符创建一个发射单个数据项的Observable或Flowable，然后使用`map`操作符对数据进行转换，最后使用`subscribe`方法订阅并打印结果。 需要注意的是，默认情况下，RxJava相关代码是同步...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值