RxJava-变换操作符和过滤操作符

变换操作符

map()	对序列的每一项都用一个函数来变换Observable发射的数据序列
flatMap()、concatMap()、flatMapIterable()	将Observable发射的数据集合变换为Observables集合，然后将这些Observable发射的数据平坦化的放进一个单独的Observable中
switchMap()	将Observable发射的数据集合变换为Observables集合，然后只发射这些Observables最近发射过的数据
scan()	对Observable发射的每一项数据应用一个函数，然后按顺序依次发射每一个值
groupBy()	将Observable拆分为Observable集合，将原始Observable发射的数据按Key分组，每一个Observable发射一组不同的数据
buffer()	定期从Observable收集数据到一个集合，然后把这些数据集合打包发射，而不是一次发射一个
window()	定期将来自Observable的数据拆分成一些Observable窗口，然后发射这些窗口，而不是每次发射一项
cast()	在发射之前强制将Observable发射的所有数据转换为指定类型

过滤操作符

filter()	过滤数据
takeLast()	只发射最后的N项
last()	只发射最后一项数据
lastOrDefault()	只发射最后一项数据，如果 Observable为空，就发送默认数据
takeLastBuffer()	将最后的N项数据当作单个数据发射
skip()	跳过开始N项数据
skipLast()	跳过最后的N项数据
take()	只发射开始的N项数据
first()/takeFirst()	只发射第一项数据，或者满足某种条件的第一项数据
firstOrDefault()	只发射第一项数据，如果Observable为空，就发射默认值
elementAt()	发射第N项数据
elementAtOrDefault()	发射第N项数据，如果Observable数据少于N项，就发射默认值
sample()/throttleLast()	定期发射Observable最近的数据
throttleFirst()	定期发射Observable发射的第一项数据
throttleWithTimeout()/debounce()	只有当Observable在指定的时间段后还没有发射数据时，才发射一个数据
timeout()	如果在一个指定的时间段后还没发射数据，就发射一个异常
distinct()	过滤掉重复的数据
distinctUntilChanged()	过滤掉连续重复的数据
ofType()	只发射指定类型的数据
ignoreElements	丢弃所有正常的数据，只发射错误或完成通知

map/flatMap

// map
        // 对Observable发射的每一项数据应用一个函数,执行变换操作
        Observable.just("HELLO")
                .map(String::toLowerCase)
                .map(v -> v + " world")
                .subscribe(System.out::println);

        // flatMap
        // 将一个发射数据Observable变换为多个Observables,然后将它们发射的数据合并后放进
        // 一个单独的Observable
        Observable.just(List.of("HELLO", "WORLD"))
                .flatMap(Observable::fromIterable)
                .subscribe(System.out::println);

groupBy

// groupBy
        //一个Observable拆分为一些Observables集合，它们中每一个都发射原始Observable的一个子序列
        Observable.range(1, 9)
                .groupBy(v -> v % 2 == 0 ? "偶数" : "奇数")
                .subscribe(v -> System.out.println(v.getKey()));

 

buffer/window

// buffer
        // 会定期收集Observable数据并放进一个数据包裹，然后发射这些数据包裹，而不是一次发射一个值
        Observable.range(1, 10)
                .buffer(3)
                .subscribe(System.out::println);

        Observable.range(1, 10)
                //从Observable的第一项数据开始创建新的缓存，以后每当收到skip项数据，就用
                //count项数据填充缓存（缓存会有重叠）
                .buffer(3,1)
                .subscribe(System.out::println);
                
                  // window
        // 定期将来自原始Observable的数据分解为一个Observable窗口，发射这些窗口，而不是每次发射一项数据
        Observable.range(1, 10)
                .window(2)
                .subscribe(
                        v -> {
                            System.out.println("onNext:");
                            v.subscribe(System.out::println);
                        }
                );
                

first/last

// first 只发射第一项
        // last 只发射最后一项
        Observable.just(1, 2, 3)
                .first(1)
                .subscribe(System.out::println);
        Observable.just(1, 2, 3)
                .last(1)
                .subscribe(System.out::println);

take/takeLast

// take
        // 只修改Observable的行为，返回前面n项数据，发射完成通知，忽略剩余数据
        Observable.just(1, 2, 3)
                .take(1)
                .subscribe(System.out::println);
        // 默认在computation调度上执行
        Observable.intervalRange(0, 10, 1, 1, TimeUnit.SECONDS)
                .take(3, TimeUnit.SECONDS)
                .subscribe(System.out::println);

        // takeLast操作符
        Observable.just(1, 2, 3)
                .takeLast(1)
                .subscribe(System.out::println);
        // 默认在computation调度上执行
        Observable.intervalRange(0, 10, 1, 1, TimeUnit.SECONDS)
                .takeLast(3, TimeUnit.SECONDS)
                .subscribe(System.out::println);
        TimeUnit.SECONDS.sleep(10000);

skip/skipLast

// skip
        // 抑制Observable发射的前n项数据
        Observable.just(1, 2, 3)
                .skip(1)
                .subscribe(System.out::println);
        // 默认在computation调度上执行
        Observable.interval( 1, TimeUnit.SECONDS)
                .skip(3, TimeUnit.SECONDS)
                .subscribe(System.out::println);

        // skipLast
        // 抑制Observable发射的后n项数据
        Observable.just(1, 2, 3)
                .skipLast(1)
                .subscribe(System.out::println);
        // 默认在computation调度上执行
        Observable.interval( 1, TimeUnit.SECONDS)
                .skipLast(3, TimeUnit.SECONDS)
                .subscribe(System.out::println);

        TimeUnit.SECONDS.sleep(10000);

elementAt/ignoreElements

// elementAt
        // 获取原始Observable发射的数据序列指定索引位置的数据项，然后当作自己的唯一数据发射
        Observable.just(1, 2, 3, 4, 5)
                .elementAt(2)
                .subscribe(System.out::println);

        Observable.just(1, 2, 3, 4, 5)
                // 如果索引超过了数据,则发射默认值
                .elementAt(10, 0)
                .subscribe(System.out::println);

        // ignoreElements
        // 不发射任何数据，只发射终止信息
        Observable.just(1, 2, 3, 4, 5)
                .ignoreElements()
                .subscribe(() ->
                                System.out.println("done"),
                        System.out::println);

distinct/filter

// distinctUntilChanged
        // 只判断数据是否与直接前驱相同
        Observable.just(1, 2, 3, 4, 5, 5, 1)
                .distinctUntilChanged()
                .subscribe(System.out::println);

        // filter
        // 只发射通过谓词测试的数据项
        Observable.just(1, 2, 3, 4, 5, 5, 1)
                .filter((v) -> v > 2)
                .subscribe(System.out::println);

debounce

 // debounce
        // 仅在过了一段指定的时间还没发射数据时才发射一个数据
        // 主要时过滤掉发射速率过快的数据项
        Observable.create((emitter) -> {
            if (emitter.isDisposed()) {
                return;
            }
            for (int i = 0; i < 10; i++) {
                emitter.onNext(i);
                TimeUnit.SECONDS.sleep(i);
            }
            emitter.onComplete();
            // 速率小于3秒的数据会被忽略,所以会从4开始打印
        })
                .debounce(3, TimeUnit.SECONDS)
                .subscribe(System.out::println);

        TimeUnit.SECONDS.sleep(10);