RxJava转换操作符

最新推荐文章于 2022-09-18 23:33:57 发布
最新推荐文章于 2022-09-18 23:33:57 发布
阅读量131 收藏
点赞数 1
分类专栏： RxJava 文章标签： Rxjava 转换 map flapMap window
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hbgaozhiwei/article/details/86531496
版权
  1. map():可以将被观察者发送的数据类型转换成其他的类型。
方法预览
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper)

Observable.just(1, 2, 3)
.map(new Function < Integer, String > () {
    @Override
    public String apply(Integer integer) throws Exception {
        return "I'm " + integer;
    }
})
.subscribe(new Observer < String > () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.e(TAG, "===================onSubscribe");
    }

    @Override
    public void onNext(String s) {
        Log.e(TAG, "===================onNext " + s);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

打印结果

===================onSubscribe
===================onNext I'm 1
===================onNext I'm 2
===================onNext I'm 3

2、flatMap():这个方法将事件序列中的元素进行整合加工，返回一个新的被观察者。返回的是Observerable。

假设一个有一个 Person 类，这个类的定义如下：

public class Person {

    private String name;
    private List<Plan> planList = new ArrayList<>();

    public Person(String name, List<Plan> planList) {
        this.name = name;
        this.planList = planList;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Plan> getPlanList() {
        return planList;
    }

    public void setPlanList(List<Plan> planList) {
        this.planList = planList;
    }

}

Person 类有一个 name 和 planList 两个变量，分别代表的是人名和计划清单。

Plan 类的定义如下：

public class Person {

    private String name;
    private List<Plan> planList = new ArrayList<>();

    public Person(String name, List<Plan> planList) {
        this.name = name;
        this.planList = planList;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Plan> getPlanList() {
        return planList;
    }

    public void setPlanList(List<Plan> planList) {
        this.planList = planList;
    }

}

现在有一个需求就还是将Person集合中的每个元素中的plan的Action打印出来，其中一个方案

Observable.fromIterable(personList)
.map(new Function < Person, List < Plan >> () {
    @Override
    public List < Plan > apply(Person person) throws Exception {
        return person.getPlanList();
    }
})
.subscribe(new Observer < List < Plan >> () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(List < Plan > plans) {
        for (Plan plan: plans) {
            List < String > planActionList = plan.getActionList();
            for (String action: planActionList) {
                Log.d(TAG, "==================action " + action);
            }
        }
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

可以看到onNext（）用了嵌套来实现的，如果代码逻辑复杂的话，可能需要多重循环实现。以下是使用flatMap()实现的：

Observable.fromIterable(personList)
.flatMap(new Function < Person, ObservableSource < Plan >> () {
    @Override
    public ObservableSource < Plan > apply(Person person) {
        return Observable.fromIterable(person.getPlanList());
    }
})
.flatMap(new Function < Plan, ObservableSource < String >> () {
    @Override
    public ObservableSource < String > apply(Plan plan) throws Exception {
        return Observable.fromIterable(plan.getActionList());
    }
})
.subscribe(new Observer < String > () {
    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "==================action: " + s);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
});

上面使用两个flatMap()就完成了需求，并且代码逻辑非常的清晰和简洁。

3、concatMap():和flatMap()基本上是一样。只不过concatMap()转发出来的是有序的，而flapMap()是无序的。

4、buffer():从需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区当中一并发出。
buffer(int count, int skip)
count: 缓冲区元素的数量
skip:缓冲区满了之后，发送下一次事件序列的时候要跳过多少元素。

Observable.just(1, 2, 3, 4, 5)
.buffer(2, 1)
.subscribe(new Observer < List < Integer >> () {
  @Override
  public void onSubscribe(Disposable d) {

  }

  @Override
  public void onNext(List < Integer > integers) {
      Log.d(TAG, "================缓冲区大小： " + integers.size());
      for (Integer i: integers) {
          Log.d(TAG, "================元素： " + i);
      }
  }

  @Override
  public void onError(Throwable e) {

  }

  @Override
  public void onComplete() {

  }
});

打印结果

================缓冲区大小： 2
================元素： 1
================元素： 2
================缓冲区大小： 2
================元素： 2
================元素： 3
================缓冲区大小： 2
================元素： 3
================元素： 4
================缓冲区大小： 2
================元素： 4
================元素： 5
================缓冲区大小： 1
================元素： 5

每次发送事件，指针都会往后移动一个元素再取值，直到指针移动道没有元素的时候就会停止取值

5、groupBy():将发送的数据进行分组，每个分组都会返回一个被观察者。

Observable.just(5, 2, 3, 4, 1, 6, 8, 9, 7, 10)
.groupBy(new Function < Integer, Integer > () {
    @Override
    public Integer apply(Integer integer) throws Exception {
        return integer % 3;
    }
})
.subscribe(new Observer < GroupedObservable < Integer, Integer >> () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "====================onSubscribe ");
    }

    @Override
    public void onNext(GroupedObservable < Integer, Integer > integerIntegerGroupedObservable) {
        Log.d(TAG, "====================onNext ");
        integerIntegerGroupedObservable.subscribe(new Observer < Integer > () {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "====================GroupedObservable onSubscribe ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "====================GroupedObservable onNext  groupName: " + integerIntegerGroupedObservable.getKey() + " value: " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "====================GroupedObservable onError ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "====================GroupedObservable onComplete ");
            }
        });
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "====================onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "====================onComplete ");
    }
});

在groupBy()方法返回的参数是分组的名字，每返回一个值，那代表会创建一个组，以上就是把1-10的数据分成三组。
打印结果

====================onSubscribe 
====================onNext 
====================GroupedObservable onSubscribe     ====================GroupedObservable onNext  groupName: 2 value: 5
====================GroupedObservable onNext  groupName: 2 value: 2
====================onNext 
====================GroupedObservable onSubscribe 
====================GroupedObservable onNext  groupName: 0 value: 3
====================onNext 
====================GroupedObservable onSubscribe 
====================GroupedObservable onNext  groupName: 1 value: 4
====================GroupedObservable onNext  groupName: 1 value: 1
====================GroupedObservable onNext  groupName: 0 value: 6
====================GroupedObservable onNext  groupName: 2 value: 8
====================GroupedObservable onNext  groupName: 0 value: 9
====================GroupedObservable onNext  groupName: 1 value: 7
====================GroupedObservable onNext  groupName: 1 value: 10
====================GroupedObservable onComplete 
====================GroupedObservable onComplete 
====================GroupedObservable onComplete 
====================onComplete

6、scan():将数据以一定的逻辑聚合起来。

Observable.just(1, 2, 3, 4, 5)
.scan(new BiFunction < Integer, Integer, Integer > () {
    @Override
    public Integer apply(Integer integer, Integer integer2) throws Exception {
        Log.d(TAG, "====================apply ");
        Log.d(TAG, "====================integer " + integer);
        Log.d(TAG, "====================integer2 " + integer2);
        return integer + integer2;
    }
})
.subscribe(new Consumer < Integer > () {
    @Override
    public void accept(Integer integer) throws Exception {
        Log.d(TAG, "====================accept " + integer);
    }
});

打印结果

====================accept 1
====================apply 
====================integer 1
====================integer2 2
====================accept 3
====================apply 
====================integer 3
====================integer2 3
====================accept 6
====================apply 
====================integer 6
====================integer2 4
====================accept 10
====================apply 
====================integer 10
====================integer2 5
====================accept 15

7、window():发送指定数量的事件事，就会将这些事件分为一组。

public final Observable<Observable<T>> window(long count)
......

Observable.just(1, 2, 3, 4, 5)
.window(2)
.subscribe(new Observer < Observable < Integer >> () {
    @Override
    public void onSubscribe(Disposable d) {
        Log.d(TAG, "=====================onSubscribe ");
    }

    @Override
    public void onNext(Observable < Integer > integerObservable) {
        integerObservable.subscribe(new Observer < Integer > () {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "=====================integerObservable onSubscribe ");
            }

            @Override
            public void onNext(Integer integer) {
                Log.d(TAG, "=====================integerObservable onNext " + integer);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "=====================integerObservable onError ");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "=====================integerObservable onComplete ");
            }
        });
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "=====================onError ");
    }

    @Override
    public void onComplete() {
        Log.d(TAG, "=====================onComplete ");
    }
});

输出结果

=====================onSubscribe 
=====================integerObservable onSubscribe 
=====================integerObservable onNext 1
=====================integerObservable onNext 2
=====================integerObservable onComplete 
=====================integerObservable onSubscribe 
=====================integerObservable onNext 3
=====================integerObservable onNext 4
=====================integerObservable onComplete 
=====================integerObservable onSubscribe 
=====================integerObservable onNext 5
=====================integerObservable onComplete 
=====================onComplete

从结果可以发现，window将1-5事件分成了3组

hbgaozhiwei
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava之转换操作符
行云间
05-14 5808
在 RxJava- 操作符之过滤Observables 了解到，RxJava过滤操作符的基本使用，主要是针对Observable列表。本篇主要针对Observable列表中对象操作符的使用。用于变换可观测序列来创建一个能够更好的满足我们需求的序列。 map       map操作符通过指定一个的Func对象，将Observables转换为一个新的Observable对象并发射，观察者将收
rxjava常用操作符
05-17
### RxJava常用操作符 #### 一、Observable的创建 RxJava的核心概念之一是`Observable`，它代表了数据源，能够发出数据项序列。在实际应用中，我们需要通过不同的方式来创建`Observable`，从而启动事件流。下面将...
Rxjava的学习之变换操作符—scan
源代码的博客
04-05 725
一、scan(Func2))       连续地对数据序列的每一项应用一个函数，然后连续发射结果      Scan操作符对原始Observable发射的第一项数据应用一个函数，然后将那个函数的结果作为自己的第一项数据发射。它将函数的结果同第二项数据一起填充给这个函数来产生它自己的第二项数据。它持续进行这个过程来产生剩余的数据序列。这个操作符在某些情况下被叫做accumulator。 Observ
RxJava系列3(转换操作符)
苏白的专栏
09-01 462
作者：张磊(BaronZhang) 链接：https://zhuanlan.zhihu.com/p/21926591 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 前面两篇文章中我们介绍了RxJava的一些基本概念和RxJava最简单的用法。从这一章开始，我们开始聊聊RxJava中的操作符Operators，RxJava中的操作符主要分成了三类：
Rxjava转换操作符
hongxue8888的博客
09-25 145
文章目录1 Map2 FlatMap3 GroupBy4 Buffer 参考：https://www.jianshu.com/p/904c14d253ba 作用 ： 将事件类型转换成我们所要的结果类型。 Map FlatMap GroupBy Buffer Scan Window 以下代码在单元测试的ExampleUnitTest中运行。 1 Map 对 被观察者发送的每1个事件都通过 指定的...
RxJava----操作符：转换操作符
qq_20198405的博客
04-27 2264
Transforming Observables(Observable的转换操作符) 本节介绍转换数据流中数据的方法。在真实世界中， Observable中的数据可以是任意类型的，可能在你的应用中无法直接使用这些数据类型，你需要对这些数据对象进行一些转换。map 和 flatMap 是本节中操作函数的基础。 下面是三种转换方式的示意： Ana(morphism) T –> IObservabl
RxJava 操作符 图片
03-31
在这个主题中，我们将深入探讨 RxJava 中的操作符，这些操作符是 RxJava 的核心组成部分，它们提供了丰富的功能来创建、转换、过滤和组合数据流。 首先，我们来了解一下什么是操作符。在 RxJava 中，操作符是用于...
Java的RxJava库操作符的用法及实例讲解
09-02
RxJava的核心是Observable（可观测序列）和Subscriber（订阅者），它们之间的交互通过一系列的操作符来实现。操作符是RxJava的核心特性，它们允许对Observable发出的数据进行各种变换和过滤。 首先，让我们深入了解...
RxJava操作符
07-01
2. **转换操作符** - `map()`: 对Observable发射的每个项应用一个函数，然后发射结果。 - `flatMap()`: 将一个Observable的每一项转换为另一个Observable，然后合并这些Observables的结果。 - `concatMap()`: ...
Rxjava功能操作符的使用方法详解
08-28
Rxjava功能操作符的使用方法详解 Rxjava是一个非常强大的Reactive Extensions库，提供了多种功能操作符来处理异步数据。下面我们将逐一介绍Rxjava功能操作符的使用方法详解。 一、Rxjava的基本概念 在Rxjava中，...
3. RxJava转换操作符
NorthStar的博客
07-30 542
RxJava转换操作符
RxJava(二)-转换操作符
最新发布
牛永志的专栏
09-18 532
RxJava 转换操作符
RxJava2 转换操作符
李岳锋的专栏
02-28 1098
前言： 本文将在Rx官方解释的基础上，再融合其它国内讲解的文章。尽量用最简单的，易懂的方式，解释这些操作符。废话不多说，先列个表，把所有操作符列出来，再一 一做解释。解释的过程，以问答的形式(基于问题来学习)，先从整体简单解释入手，并配上能跑的示例代码(0 warnings, 0 errors)。先知道能做什么和怎么做，再讲原理，并尽量做到中英融合解释。这是官方文档：Transforming O...
RxJava操作符（二）----转换操作符
zengke的博客
05-21 2241
转换操作符： 变换被观察者(Observable)发送的事件。将Observable发送的数据按照一定的规则做一些变换，然后再将变换的数据发射出去。 变换的操作符有map,flatMap，concatMap,switchMap,buffer,groupBy等等。 1、map()操作符 /** * ======================map=================...
RxJava使用详解--转换操作符
xiaochuanding的博客
12-18 1971
RxJava使用详解系列文章 《RxJava使用详解--创建操作符 》 这篇文章主要将RxJava中常见 的转换操作符。 1.Buffer(): 定期收集Observable的数据放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一个值。Buffer操作符将一个Observable变换成另一个，原来的Observable正常发射数据，变换产生的Observ
Android ：RxJava学习笔记之转换操作符
JMW1407的博客
11-03 491
RxJava ——转换操作符 转换操作符1、map2、cast3、flatMap4、concatMap4.1、concatMap和flatmap对比5、flatMapIterable6、scan7、buffer8、window9、groupBy参考 转换操作符 转换类操作符顾名思义，就是将上游（被观察者）发送的数据流进行转换成另外一种形式（观察者希望接收到的形式），从而使下游（观察者）能够正确的接受并作出响应。 这里介绍map，cast，flatMap，concatMap，flatMapIterable，
初识RxJava（三）转换类 操作符
weixin_34326179的博客
11-09 127
前言： 昨天的两篇介绍了 RxJava 的创建类操作符和延时类操作符，今天笔者记录一下 转换类 操作符，不太监了 ，开始记笔记。对了具体不太清楚转换过程的 可以去拜读 这位大佬 Season_zlc 关于 map 等操作符的介绍 链接为：给初学者的RxJava2.0教程(三) 。 正文： 1、map 操作符 1)、作用 将观察者 发射的 数据 从发射...
RxJava转换类型操作符
leilifengxingmw的博客
09-25 672
1 buffer buffer操作符周期性地收集源Observable产生的结果到列表中，并把这个列表提交给订阅者，订阅者处理后，清空buffer列表，同时接收下一次收集的结果并提交给订阅者，周而复始需要注意的是，一旦源Observable在产生结果的过程中出现异常，即使buffer已经存在收集到的结果，订阅者会马上收到这个异常，buffer中的结果不会发出。 int num = 1;
RxJava学习之转换型操作符
wuyinlei的博客
03-09 962
RxJava学习之转换型操作符
RxJava入门：常用操作符详解
"本文将介绍RxJava入门中常用的操作符，包括Observable的创建，特别是from()和just()两个方法的使用。" RxJava是一种用于处理异步数据流的库，它引入了响应式编程的概念，使得处理事件和数据变得更加简洁高效。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值