rxjava : 过滤操作符：filter(条件过滤)、 distinct(去重)、ofType(类型过滤）、buffer(缓存)

已于 2022-07-13 17:36:57 修改
阅读量984 收藏
点赞数
分类专栏： rxjava 文章标签： rxjava 缓存 android
于 2019-09-27 17:52:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_31057219/article/details/101549254
版权

filter :

根据过滤规则过滤数据

@Test
public void filter() {
    ArrayList<Student> students = new ArrayList<>();
    students.add(new Student("1", 1));
    students.add(new Student("2", 20));
    students.add(new Student("2", 21));
    students.add(new Student("2", 23));
    students.add(new Student("3", 3));
    students.add(new Student("4", 4));
    students.add(new Student("5", 50));
    students.add(new Student("6", 6));
    students.add(new Student("7", 7));
    Disposable disposable = Observable.fromIterable(students)
            .filter(student -> student.getAge() > 21)
            .subscribe(student ->
                    System.out.println("student==========="
                            + student.toString()));
}
//student===========Student{name='2', age=23}
//student===========Student{name='5', age=50}

distinct : 去重

/**
 * 去重 ： distinct
 */
@Test
public void distinct1() {
    Disposable disposable = Observable
    		.just("a", "d", "b", "c", "a", "e", "b", "c", "a", "b")
            .distinct()
            .subscribe(new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.println("s=============" + s);
                }
            });
}
//s=============a
//s=============d
//s=============b
//s=============c
//s=============e

/**
 * 去重对象 ： distinct
 */
@Test
public void distinct2() {
    ArrayList<Student> students = new ArrayList<>();
    students.add(new Student("1", 1));
    students.add(new Student("2", 20));
    students.add(new Student("2", 21));
    students.add(new Student("2", 23));
    students.add(new Student("3", 3));
    students.add(new Student("4", 4));
    students.add(new Student("5", 50));
    students.add(new Student("6", 6));
    students.add(new Student("7", 7));
    Disposable disposable = Observable.fromIterable(students)
            .distinct(new Function<Student, String>() {
                @Override
                public String apply(Student student) throws Exception {
                    return student.getName();//如果两个学生name一样就过滤（去重）
                    //return student.getName() + student.getAge(); //如果多个条件同时，可以采取属性拼接的方式
                }
            })
            .subscribe(new Consumer<Student>() {
                @Override
                public void accept(Student student) throws Exception {
                    System.out.println("student==========="
                            + student.toString());
                }
            });
}
//student===========Student{name='1', age=1}
//student===========Student{name='2', age=20}
//student===========Student{name='3', age=3}
//student===========Student{name='4', age=4}
//student===========Student{name='5', age=50}
//student===========Student{name='6', age=6}
//student===========Student{name='7', age=7}

public class Student {

    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

distinct : 去重二


   /**
     * 去重对象 2个条件并再次组合成集合 ： distinct
     */
    public void distinct3() {
        ArrayList<Student> students = getStudents();

        Disposable disposable = Observable.fromIterable(students)
                .distinct(new Function<Student, Integer>() {
                    @Override
                    public Integer apply(Student student) throws Exception {
                        //返回过滤条件，如果为默认值0，不过滤
                        return student.getAge() != 0 ?
                                student.getAge() :
                                new Random().nextInt(Integer.MAX_VALUE);
                    }
                })
                .distinct(new Function<Student, String>() {
                    @Override
                    public String apply(Student student) throws Exception {
                        //返回过滤条件，如果为空，不过滤
                        return !TextUtils.isEmpty(student.getName()) ?
                                student.getName() :
                                UUID.randomUUID().toString();
                    }
                })
                .toList()   //再合并各个数据
                .subscribe(new Consumer<List<Student>>() {
                    @Override
                    public void accept(List<Student> students) throws Exception {
                        if (students != null) {
                            for (int i = 0; i < students.size(); i++) {
                                System.out.println("students======"
                                        + students.get(i).toString());
                            }
                        }
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        System.out.println("throwable======"
                                + throwable.getMessage());
                    }
                });
    }
    //students======Student{name='1', age=11, school='11'}
    //students======Student{name='2', age=21, school='21'}
    //students======Student{name='3', age=31, school='31'}
    //students======Student{name='4', age=41, school='41'}
    //students======Student{name='5', age=51, school='51'}
    //students======Student{name='6', age=61, school='61'}
    //students======Student{name='7', age=71, school='71'}
    //students======Student{name='8', age=81, school='81'}
    //students======Student{name='9', age=91, school='91'}
    //students======Student{name='null', age=92, school='92'}
    //students======Student{name='null', age=93, school='93'}
    //students======Student{name='null', age=0, school='95'}
    //students======Student{name='null', age=0, school='96'}
    //students======Student{name='10', age=0, school='101'}

    private ArrayList<Student> getStudents() {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("1", 11, "11"));

        students.add(new Student("2", 21, "21"));
        students.add(new Student("2", 22, "22"));
        students.add(new Student("3", 22, "23"));
        students.add(new Student("3", 31, "31"));
        students.add(new Student("4", 41, "41"));
        students.add(new Student("4", 41, "42"));

        students.add(new Student("5", 51, "51"));
        students.add(new Student("6", 61, "61"));
        students.add(new Student("7", 71, "71"));

        students.add(new Student("8", 81, "81"));
        students.add(new Student("8", 81, "82"));
        students.add(new Student("8", 82, "83"));

        students.add(new Student("9", 91, "91"));
        students.add(new Student(null, 92, "92"));
        students.add(new Student(null, 93, "93"));
        students.add(new Student(null, 93, "94"));
        students.add(new Student(null, 0, "95"));
        students.add(new Student(null, 0, "96"));
        students.add(new Student("10", 0, "101"));
        return students;
    }


public class Student {

    private String name;
    private int age;
    private String school;

    public Student(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", school='" + school + '\'' +
                '}';
    }
}

ofType : 类型过滤

@Test
public void ofType1() {
    Disposable disposable = Observable.just("first", 2d, 3L, "four", 5, false)
            .ofType(Integer.class)//只需要Integer
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) {
                    System.out.println("integer=============" + integer);
                }
            });
}
//integer=============5




//类型过滤
@Test
public void ofType2() {
    Object[] data = {"first", "2", 3, "four", 5, 6, 7};
    Disposable disposable = Observable.fromArray(data)
            .ofType(Integer.class)
            .filter(new Predicate<Integer>() {
                @Override
                public boolean test(Integer integer) throws Exception {
                    return integer > 5;
                }
            })
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println("integer=============" + integer);
                }
            });
}
//integer=============6
//integer=============7

buffer : 缓存

buffer:隔m（skip）个数取n（count）个数

“buffer”允许您收集值并以批量形式获取它们，而不是一次收集一个值。它们是缓冲值的几种不同方式。

@Test
public void buffer1() {
    Disposable disposable = Observable.range(1, 10)
            .buffer(2)//每次take两个
            .subscribe(System.out::println);
}
//[1, 2]
//[3, 4]
//[5, 6]
//[7, 8]
//[9, 10]




@Test
public void buffer2() {
    //skip分组[1,2,3][4,5,6][7,8,9][10]，再take取值
    //当count < skip,元素被排除在外
    Disposable disposable = Observable.range(1, 10)
            .buffer(2, 3)//每次skip三个，只take两个
            .subscribe(System.out::println);
}
//[1, 2]
//[4, 5]
//[7, 8]
//[10]




@Test
public void buffer3() {
    //skip分组[1,2][3,4][5,6][7,8][9,10]，再take取值
    //当count > skip,缓冲区重叠
    Disposable disposable = Observable.range(1, 10)
            .buffer(3, 2)
            .subscribe(System.out::println);

}
//[1, 2, 3]
//[3, 4, 5]
//[5, 6, 7]
//[7, 8, 9]
//[9, 10]




@Test
public void buffer4() {
    //skip分组[1,2][3,4][5,6][7,8][9,10]，再take取值
    Disposable disposable = Observable.range(1, 10)
            //count : 每个缓冲区应发出的最大大小
            //skip : 开始新的缓冲区之前，应跳过源ObservableSource发出的多少项。
            // 请注意，当{@code skip}和{@code count}相等时，
            // 此操作与 {@link #buffer（int）}相同。
            .buffer(2, 2)
            .subscribe(System.out::println);
}
//[1, 2]
//[3, 4]
//[5, 6]
//[7, 8]
//[9, 10]





@Test
public void buffer5() {
    PublishSubject<String> subject = PublishSubject.create();
    Disposable disposable = subject
            .buffer(3)//获取三个为一组发送
            .subscribe(new Consumer<List<String>>() {
                @Override
                public void accept(List<String> stringList) throws Exception {
                    StringBuilder content = new StringBuilder();
                    for (String s : stringList) {
                        content.append(s).append(",");
                    }
                    System.out.println("content=======" + content);
                }
            });
    subject.onNext("1");
    subject.onNext("2");
    subject.onNext("3");
    subject.onNext("4");
    subject.onNext("5");
    subject.onNext("6");
    subject.onNext("7");
    subject.onNext("8");
    subject.onNext("9");
    subject.onNext("10");
    subject.onComplete();
}
//content=======1,2,3,
//content=======4,5,6,
//content=======7,8,9,
//content=======10,
Mars-xq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Database-Using-RxJava:使用RxJava和更多过滤器SQLite
05-01
3. **过滤器操作符**：RxJava提供了一系列过滤操作符，如filter()、distinct()、skip()、take()等，这些操作符可以帮助我们根据条件筛选数据。在与SQLite结合时，这可以用来实现复杂的查询逻辑，比如只获取满足特定...
django model 条件过滤 queryset.filter(**condtions)用法详解
09-16
本篇文章将深入探讨`queryset.filter()`的用法及其相关的条件过滤操作。 首先，`queryset.filter(**conditions)`方法用于获取满足特定条件的模型实例。这里的`**conditions`是一个字典，其键值对对应于模型字段和...
Rxjava3文档级教程二： 操作符全解
许进进的博客
04-05 9935
1 前言 1.1 用操作符组合Observable 对于ReactiveX来说，Observable和Observer仅仅是个开始，它们本身不过是标准观察者模式的一些轻量级扩展，目的是为了更好的处理事件序列。 ReactiveX真正强大的地方在于它的操作符，操作符让你可以变换、组合、操纵和处理Observable发射的数据。 Rx的操作符让你可以用声明式的风格组合异步操作序列，它拥有...
RxJava 之变换操作符和过滤操作符
weixin_33910434的博客
10-17 122
RxJava 的变换操作符主要包括以下几种 map()：对序列的每一项都用一个函数来变换 Observable 发射的数据序列 flatMap()、contactMap() 和 FlatMapIterable()：将 Observable 发射的数据集合变换为 Observables 集合，然后将这些 Observable 发射的数据平坦化地放进一个单独的 Observable 中 switch...
RxJava-变换操作符和过滤操作符
krauser1991的博客
06-02 160
变换操作符 map() 对序列的每一项都用一个函数来变换Observable发射的数据序列 flatMap()、concatMap()、flatMapIterable() 将Observable发射的数据集合变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable中 switchMap() 将...
rx java操作符_RxJava常用操作符用法
weixin_32384503的博客
02-13 401
按照官方的分类，操作符大致分为以下几种：(来源 [rxjava详细介绍](http://blog.csdn.net/job_hesc/article/details/46242117 "rxjava详细介绍"))* Creating Observables(Observable的创建操作符)，比如：Observable.create()、Observable.just()、Observable...
RxJava操作符
川峰的博客
05-15 2966
文章目录RxJava创建型操作符create()操作符just()操作符fromArray()操作符fromIterable()操作符differ()操作符timer()操作符interval()操作符intervalRange()操作符range()操作符rangeLong()操作符其他RxJava变换操作符map()操作符flatMap()操作符concatMap()操作符buffer()操作...
【RxJava】RxJava/RxAndroid的操作符使用(二)
最新发布
摸鱼小小虫的博客
11-08 431
介绍了RxJava中常用的操作符功能和使用方法
android rxjava2 简书,Android拾萃 - RxJava2操作符汇总
weixin_34364310的博客
05-28 372
几种主要的需求：直接创建一个Observable(创建操作)组合多个Observable(组合操作)对Observable发射的数据执行变换操作(变换操作)从Observable发射的数据中取特定的值(过滤操作)转发Observable的部分值(条件/布尔/过滤操作)对Observable发射的数据序列求值(算术/聚合操作)创建操作符名称解析just()将一个或多个对象转换成发射这个或这些对象的一...
RxJava的操作符
我是永恒的博客
12-04 226
RxJava中提供了大量不同种类，不同场景的Operators(操作符)，RxJava的强大性就来自于它所定义的操作符。主要分类： 创建操作：用于创建Observable的操作符； 变换操作：这些操作符可用于对Observable发射的数据进行变换； 过滤操作：这些操作符用于从Observable发射的数据中进行选择； 组合操作：组合操作符用于将多个Observable组合成一个单一的Ob...
RxJava操作符大全
热门推荐
maplejaw的博客
09-01 3万+
再也不用担心记不住RxJava中的操作符了，RxJava操作符大全，需要用时Ctrl+F一下，还有使用例子哦。
django filter过滤器实现显示某个类型指定字段不同值方式
09-16
在Django框架中，过滤器（filter）是模板语言中的一个重要功能，用于处理和操作数据。在本场景中，我们关注的是如何使用`django filter`来实现显示某个类型指定字段的不同值。`django filter`允许我们在模板中进行...
mongodb中使用distinct去重的简单方法
01-19
mongodb的distinct的语句： 代码如下: db.users.distinct(‘last_name’） 等同于 SQL 语句： 代码如下: select DISTINCT last_name from users 表示的是根据指定的字段返回不同的记录集。 一个简单的实例： //...
rxjava：错误处理操作符（2）： onErrorReturn 、 onErrorResumeNext 、onExceptionResumeNext
火星男孩的分享空间
09-24 5381
//让Observable遇到错误时发射一个特殊的项并且正常终止， // onErrorRetrun能够捕获在它之前发生的异常，它之后流中的操作发生的异常就它就不会管了。 public void onErrorReturn() { Observable.create(getObservableOnSubscribe()) .subscribeOn(Scheduler...
rxjava ： 常用的 compose 与 ObservableTransformer
火星男孩的分享空间
10-08 3900
RxJavaUtils 工具类 public class RxJavaUtils { public static <T> ObservableTransformer<T, T> applySchedulers() { return new ObservableTransformer<T, T>() { @Over...
rxjava : 错误处理操作符 （1）：retry 、 retryUntil 、 retryWhen
火星男孩的分享空间
09-24 3704
参考：[Android开发] RxJava2之路七 - 错误处理操作符例子Demo retry操作符 重试的意思，拦截到错误，然后让 被观察者重新发射数据。Throwable和Exception都额可以拦截 它有五种参数方法: retry(): 让被观察者重新发射数据，要是一直错误就一直发送了 retry(BiPredicate)： interger是第几次重新发送，Throwable是错...
okhttp：应用拦截器和网络拦截器区别
火星男孩的分享空间
04-04 2985
Each interceptor chain has relative merits. 每个拦截器各有自己的优点 Application interceptors：应用拦截器 Don’t need to worry about intermediate responses like redirects and retries. Are always invoked once, even...
rxjava ： compose 与 ObservableTransformer、lift 与 ObservableOperator
火星男孩的分享空间
10-08 2634
compose 与 ObservableTransformer ： //操作被观察者（abstract class Observable<T> implements ObservableSource<T> ） //将源ObservableSource整体转换 //通过对它应用特定的Transformer函数来转换ObservableSource。 //此方法在Obs...
探索RxJava：从基础到高级操作符详解
- **过滤操作**：如Debounce避免重复发射，Distinct去重，Skip/Take限制元素数量，Sample抽样等。 - **结合操作**：如And/Then/When组合多个操作，CombineLatest合并多个流的最新值，Join合并两个流，Merge并行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值