RxJava 事件流之过滤数据

最新推荐文章于 2024-09-04 09:14:43 发布
最新推荐文章于 2024-09-04 09:14:43 发布
阅读量1.4w 收藏 1
点赞数
分类专栏： RxJava入门 文章标签： 函数式编程 RxJava

现在你可以用 Rx 来处理大批量实时数据，但是如果把所有大批量数据整个打包发给你的话，使用 Rx 还有啥优势呢？ 本节 我们将介绍一些操作函数（operators ）来过滤数据、或者把所有数据变成一个需要的数据。

如果你了解过函数式编程（functional programming）或者 Java 中的 Stream，则本节介绍的操作函数是非常眼熟的。本节中所有的操作符都返回一个不影响前一个 Observable 的新 Observable。 整个 Rx 框架都遵守该原则。通过创建新的 Observable 来转换之前的 Observable而不会对之前的 Observable 造成干扰。订阅到初始 Observable 的 Subscribers 不会受到任何影响，但是在后面的章节中也会看到，开发者也需要当心该原则。
Marble diagrams（弹子图）

你可以想象一个机器，不停的发射弹子出来，发射出来的弹子可以被其他模块再次加工（比如 上色、把不合格的弹子给回收了），加工完成后再次发射出来 … 弹子图就是对这个机器的抽象描述。在 Rx 中流行使用这种方式来描述操作符，毕竟图片看起来直观多了。 Marble diagrams（弹子图）基本元素如下：

这里写图片描述

时间从左往右流动，每个图形代表一个数据，竖线代表发射完成了，而 X 代表出现错误了。 操作函数把上面的 Observable 转换下面的新的 Observable ， 里面的每个数据都被操作函数给处理了并返回一个新的数据。

Filter（过滤数据）

filter 函数使用一个 predicate 函数接口来判断每个发射的值是否能通过这个判断。如果返回 true，则该数据继续往下一个（过滤后的） Observable 发射。

这里写图片描述

比如下面示例创建了一个发射 0 到 9 十个数字的 源Observable。在该 Observable 使用一个 filter 操作来过滤掉奇数，最后只保留偶数。

Observable<Integer> values = Observable.range(0,10);
Subscription oddNumbers = values
    .filter(v -> v % 2 == 0)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

0
2
4
6
8
Completed

distinct 和 distinctUntilChanged

distinct 函数用来过滤掉已经出现过的数据了。

这里写图片描述

Observable<Integer> values = Observable.create(o -> {
    o.onNext(1);
    o.onNext(1);
    o.onNext(2);
    o.onNext(3);
    o.onNext(2);
    o.onCompleted();
});

Subscription subscription = values
    .distinct()
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

1
2
3
Completed

distinct 还有一个重载函数，该函数有个生成 key 的参数。每个发射的数据都使用该参数生成一个 key，然后使用该key 来判断数据是否一样。

public final <U> Observable<T> distinct(Func1<? super T,? extends U> keySelector)

这里写图片描述

下面示例中使用字符串的第一个字母作为 key 来比较。

Observable<String> values = Observable.create(o -> {
    o.onNext("First");
    o.onNext("Second");
    o.onNext("Third");
    o.onNext("Fourth");
    o.onNext("Fifth");
    o.onCompleted();
});

Subscription subscription = values
    .distinct(v -> v.charAt(0))
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果：

First
Second
Third
Completed

“Fourth” 和 “Fifth” 字符串被过滤掉了，应为他们的 key （首字母）和 First 一样。已经发射过的数据将被过滤掉。

有经验的码农知道，该函数在内部维护一个 key 集合来保存所有已经发射数据的 key，当有新的数据发射的时候，在集合中查找该 数据的key 是否存在。 在使用 Rx 操作函数的时把内部细节给封装起来了，但是我们应该注意该问题来避免性能问题。（如果有大量的数据，维护一个内部的集合来保存 key 可能会占用很多内存。）

distinct 还有个变体是 distinctUntilChanged。区别是 distinctUntilChanged 只过滤相邻的 key 一样的数据。

public final Observable<T> distinctUntilChanged()
public final <U> Observable<T> distinctUntilChanged(Func1<? super T,? extends U> keySelector)

这里写图片描述

Observable<Integer> values = Observable.create(o -> {
    o.onNext(1);
    o.onNext(1);
    o.onNext(2);
    o.onNext(3);
    o.onNext(2);
    o.onCompleted();
});

Subscription subscription = values
    .distinctUntilChanged()
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

1
2
3
2
Completed

同样 distinctUntilChanged 也可以使用一个生成 key 的参数：

Observable<String> values = Observable.create(o -> {
    o.onNext("First");
    o.onNext("Second");
    o.onNext("Third");
    o.onNext("Fourth");
    o.onNext("Fifth");
    o.onCompleted();
});

Subscription subscription = values
    .distinctUntilChanged(v -> v.charAt(0))
    .subscribe(
            v -> System.out.println(v),
            e -> System.out.println("Error: " + e),
            () -> System.out.println("Completed")
        );

输出结果：

First
Second
Third
Fourth
Completed

ignoreElements

ignoreElements 会忽略所有发射的数据，只让 onCompleted 和 onError 可以通过。

Observable<Integer> values = Observable.range(0, 10);

Subscription subscription = values
    .ignoreElements()
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

Completed

ignoreElements() 和使用 filter(v -> false) 是一样的效果。

skip 和 take

下面两个操作函数依据发射数据的索引来在特定的位置切断数据流，可以从头开始切断也可以从末尾开始切断。 take 从头开始获取前 N 个数据，而 skip 则是从头开始 跳过 N 个数据。注意，如果发射的数据比 N 小，则这两个函数都会发射一个 error。

Observable<T>   take(int num)

这里写图片描述

Observable<Integer> values = Observable.range(0, 5);

Subscription first2 = values
    .take(2)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

0
1
Completed

熟悉 Java 8 Stream 的同学知道 take 函数和 limit 类似。 limit 函数在 Rx 中也有，和 take 是一样的。只是为了方便熟悉 limit 的同学使用而已。

只要第 N 个数据可用， take 操作就结束了。 如果在 N 个数据发射之前发生了 error， error 信息会继续传递到下一个 Observable。 如果 第 N 个数据发射后， take 就不再关心源 Observable 的状态了。

Observable<Integer> values = Observable.create(o -> {
    o.onNext(1);
    o.onError(new Exception("Oops"));
});

Subscription subscription = values
    .take(1)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

1
Completed

skip 返回 take 操作忽略的另外一部分数据。也就是跳过前面 N 个数据。

Observable<T>   skip(int num)

这里写图片描述

Observable<Integer> values = Observable.range(0, 5);

Subscription subscription = values
    .skip(2)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

2
3
4
Completed

除了根据发射数据的索引来过滤数据以外，还可以使用数据流发射的时间来过滤。比如过滤掉前五秒发射的数据。

Observable<T>   take(long time, java.util.concurrent.TimeUnit unit)
Observable<T>   skip(long time, java.util.concurrent.TimeUnit unit)

Observable<Long> values = Observable.interval(100, TimeUnit.MILLISECONDS);

Subscription subscription = values
    .take(250, TimeUnit.MILLISECONDS)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

0
1
Completed

上面示例中只获取前 250 毫秒发射的数据。 第 300 毫秒才开始发射数据 3， 所以这里只获取 0 和1 两个数据。

skipWhile 和 takeWhile

这两个函数是使用一个 predicate 参数来当做判断条件。 如果判断条件返回为 ture， 则 takeWhile 保留该数据。

Observable<T>   takeWhile(Func1<? super T,java.lang.Boolean> predicate)
Observable<Long> values = Observable.interval(100, TimeUnit.MILLISECONDS);

Subscription subscription = values
    .takeWhile(v -> v < 2)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果如下：

0
1
Completed

不出意料， skipWhile 跳过过滤条件为 true 的数据。

Observable<Long> values = Observable.interval(100, TimeUnit.MILLISECONDS);

Subscription subscription = values
    .skipWhile(v -> v < 2)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果：

2
3
4
...

skipLast 和 takeLast

skip 和 take 是从头开始索引数据，而 skipLast 和 takeLast 和他们相反，是从末尾开始索引数据。

Observable<Integer> values = Observable.range(0,5);

Subscription subscription = values
    .skipLast(2)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果：

0
1
2
Completed

同样这两个函数也有依时间为条件的重载函数。

takeUntil 和 skipUntil

takeUntil 和 skipUntil 这两个函数和 takeWhile 、skipWhile 刚好相反。 当判断条件为 false 的时候， takeUntil 保留该数据。

takeUntil 和 skipUntil 还有另外一种不一样的重载函数。切断的条件为 另外一个 Observable 发射数据的时刻。

// 获取源Observable的数据直到 other Observable 发射第一个数据时停止
public final <E> Observable<T> takeUntil(Observable<? extends E> other)

这里写图片描述

Observable<Long> values = Observable.interval(100,TimeUnit.MILLISECONDS);
Observable<Long> cutoff = Observable.timer(250, TimeUnit.MILLISECONDS);

Subscription subscription = values
    .takeUntil(cutoff)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果：

0
1
Completed

你应该还记得，这个 timer 函数会等待 250 毫秒然后发射一个数据。当 takeUntil 收到 这个数据的时候就停止继续接受 values 发射的数据。 cutoff 这个充当信号的 Observable 可以是任意数据类型的，这里不关心数据只关心何时发射了数据。

skipUntil 也是一样，当收到另外一个 Observable 发射数据的时候，就开始接收 源 Observable 的数据。

Observable<Long> values = Observable.interval(100,TimeUnit.MILLISECONDS);
Observable<Long> cutoff = Observable.timer(250, TimeUnit.MILLISECONDS);

Subscription subscription = values
    .skipUntil(cutoff)
    .subscribe(
        v -> System.out.println(v),
        e -> System.out.println("Error: " + e),
        () -> System.out.println("Completed")
    );

输出结果：

2
3
4
...

本文出自 云在千峰 http://blog.chengyunfeng.com/?p=960

一叶飘舟
关注
专栏目录
RxJava使用总结
u013914309的博客
06-09 1306
​##.简介 RxJava是是一个基于事件流处理来实现异步操作的库。对于需要切换线程来异步处理的场景，能够简化代码编写，提高代码可读性。官网地址：ReactiveX 一、使用流程概括和示例 1.它是按照观察者模式来设计的 被观察者负责生产事件，观察者负责处理事件，一旦观察者 订阅了 被观察者，就会触发被观察者发送事件流。 这里的“事件”是一个抽象概念，它的载体是一个数据结构(例如String/Object/自定义对象等)，传递的实际上是数据，只是在观察者模式中它们的角色是“事件”。........
RxJava过滤操作符
tinysakura的博客
02-25 379
转载自LeiHolmes的博客[https://www.jianshu.com/p/66d4dacded9b] 前言 上一篇文章我们学习了转换类操作符，本篇我们将一起来学习RxJava过滤类操作符。过滤操作符主要是用来对事件数据进行过滤与筛选，只返回满足条件的数据，一起来看下都有哪些。 过滤操作符 Filter filter操作符，按照一定的约束条件过滤序列中我们不想要的数据，只返回满足条件的数据...
Rxjava过滤函数
红豆和绿豆的博客
02-21 304
过滤的几个基本操作 filter disctinct first last take takeFirst takeLast skip SkipLast elementAt ingnoreEelements debounce （1）distinct 去除重复操作 去除重复操作，根据具体的值进行去除重复，如果是对象的化，则比较的是对象，则比较的是地址 package rxjava.filter; import io.reactivex.Observable; import rxjava.map...
深入解析Java中的分布式事件流处理：从Kafka Streams到Apache Flink
最新发布
weixin_53840353的博客
09-04 1159
事件流处理是一种处理实时数据流的技术，旨在处理从各种数据源（如传感器、社交媒体、交易系统等）不断生成的事件。事件流处理的关键目标是能实时地处理和响应数据流中的事件，而不是像传统批处理那样在固定时间间隔内处理数据。Kafka Streams是一个轻量级的Java流处理库，专为Apache Kafka设计。它允许开发者构建和部署分布式、容错和可扩展的实时流处理应用。Apache Flink是一个开源的流处理框架，支持批处理和流处理两种模式。
RxJava3案例 - FromIterable+Filter+Buffer实现列表数据过滤
bigfc的博客
12-05 1316
RxJava案例 FromIterable+Filter+Buffer实现列表数据过滤
android rxjava 过滤,RxJava(六)：过滤操作符
weixin_30340301的博客
05-26 340
RxJava 的过滤操作符主要包括以下几种：filter：过滤数据takeLast：只发射最后的 N 项数据last ：只发射最后一项数据lastOrDefault：只发射最后一项数据，如果 Observable 空，就发射默认值。takeLastBuffer ：将最后的 N 项数据当作单个数据发射skip ：跳过开始的 N 项数据skipLast：跳过最后的 N 项数据take ：只发射开始的 ...
RxJava(四)-过滤操作符
牛永志的专栏
09-18 690
过滤操作符
Database-Using-RxJava:使用RxJava和更多过滤器SQLite
05-01
RxJava是一种响应式编程库，它允许开发者以声明式的方式处理事件流，而SQLite则是一个轻量级的嵌入式数据库，常用于移动应用中存储数据。 1. **RxJava**：RxJava的核心概念是Observable（可观察者）和Observer...
RxJava入门之介绍与基本运用
09-01
RxJava 是一个专门为 Java 虚拟机设计的响应式编程库，它允许开发者通过可观察序列和 LINQ 风格的操作符来处理异步数据流和事件。响应式编程是一种编程范式，旨在处理事件和数据流，使得代码能够更优雅地处理变化和...
过滤操作符：在rxjava2中筛选和过滤数据
# 1. 引言 ## 1.1 什么是RxJava2 ## 1.2 过滤操作符的作用和重要性 ## 过滤操作符的基本概念和分类 ...在实际项目中，过滤操作符是非常常用的，可以根据不同的需求进行数据过滤和筛选。下面将介绍几个经典
响应式操作符：在rxjava2中处理异步数据流
# 1. 理解响应式操作符 ...响应式操作符是 RxJava 2 中的核心概念，它们可以用来转换、过滤、组合和处理数据流，从而实现对异步数据的处理和管理。在接下来的章节中，我们将详细介绍不同类型的响应式操作
流之过滤器流（数据流）
weixin_34268843的博客
10-12 293
为什么80%的码农都做不了架构师？>>> ...
java 数据过滤_java8 Stream流的filter方法过滤数据
weixin_39831242的博客
02-21 3040
jdk1.8以上才能使用，叫内部迭代没有写类，直接写的map，实体类也是可以用的这样看起来简洁一点public static void main(String args[]){List> list=new ArrayList<>();for(int i=0;i<5;i++){Map map=new HashMap<>();map.put("type",i);li...
用IO进行数据处理之过滤流
孤独的博客
09-09 292
过滤流 通常字节流只具有读写字节内容的方法，它们只能在文件中读取或者向文件中写入字节，在实际开发中往往需要在文件中读取或写入各种类型的数据，（整型、布尔类型等），就必须先将其他类型的数据转换成字节数组后写入文件，或者从文件中读取字节数组转换成其他数据类型，这时候需要包装类。 DataOutputStream 对于DataOutputStream必须给它一个输出流对象，完成类似DataOutput...
服务器主动推送消息数据给客户端
热门推荐
answer3lin的博客
02-11 2万+
1 引言 这个问题第一次是我在实现一个导师的方案的时候所发现的，一开始我需要实现服务器与客户端的密钥协商和数据传递，服务器需要主动分发（推送）密钥给客户端，因为以前没有做过相关编码，后来只能想到用反向连接，也就是交换C/S的身份。 再后来是在做一个机器学习的问题时候，因为机器学习模型的运行需要综合多个客户端（边缘节点）的数据，然后得到结果，而且各个客户端的数据传输是不一致的，时间和数据量不定。...
java事件的接收_消息事件接收(加密)
weixin_35108433的博客
02-27 485
package weixin.popular.example;import java.io.IOException;import java.io.OutputStream;import java.io.UnsupportedEncodingException;import java.net.URLDecoder;import java.nio.charset.Charset;import java...
java 事件流_RxJava 教程第二部分：事件流基础之 检查数据
weixin_32133403的博客
02-16 179
Inspection 检查数据是否符合某一条件前面一节介绍了如何过滤掉我们不关心的数据。有时候我们需要了解该数据流中的数据是否符合某一条件。本节来介绍一些检查数据流中数据的函数。allall 函数用来判断 observable 中发射的所有数据是否都满足一个条件。Javapublic final Observable all(Func1 super T,java.lang.Boolean> ...
java从流中读取数据_归纳从文件中读取数据的六种方法-JAVA IO基础总结第2篇
weixin_39588432的博客
02-16 1616
在上一篇文章中，我为大家介绍了《5种创建文件并写入文件数据的方法》，本节我们为大家来介绍6种从文件中读取数据的方法.Scanner(Java 1.5) 按行读数据及String、Int类型等按分隔符读数据。Files.lines, 返回Stream(Java 8) 流式数据处理，按行读取Files.readAllLines, 返回List(Java 8)Files.readString, 读取S...
RxJava 事件流之转换数据流
Dream It Possible
07-05 4078
Transformation of sequences本节介绍转换数据流中数据的方法。在真实世界中， Observable 中的数据可以是任意类型的，可能在你的应用中无法直接使用这些数据类型，你需要对这些数据对象进行一些转换。 map 和 flatMap 是本节中操作函数的基础。 下面是三种转换方式的示意： Ana(morphism) T –> Observable Cata(morphism)
深入探索Reactive Programming with RxJava：异步事件驱动开发
2. 操作符：RxJava提供了一系列操作符，用于转换、过滤、合并、延迟等数据处理任务。例如，map操作符用于应用函数到每个元素，filter用于筛选元素，concat和merge用于组合多个可观察序列。 3. 调度器：调度器在反应...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值