RxJava2总结之操作详解(一)

最新推荐文章于 2024-04-26 14:46:14 发布

Typist夫少

最新推荐文章于 2024-04-26 14:46:14 发布

阅读量4.5k

点赞数 3

文章标签： RxJava2

本文链接：https://blog.csdn.net/jackzhang_0522/article/details/77336008

版权

创建操作

create

创建一个具有发射能力的Observable

Observable.create(e -> {
    e.onNext("Love");
    e.onNext("For");
    e.onNext("You!");
    e.onComplete();
}).subscribe(s -> System.out.println(s));

just

只是简单的原样发射,可将数组或Iterable当做单个数据。它接受一至九个参数

Observable.just("Love", "For", "You!")
                .subscribe(s -> System.out.println(s));

empty

创建一个不发射任何数据但是正常终止的Observable

Observable.empty();

never

创建一个不发射数据也不终止的Observable

Observable.never();

error

创建一个不发射数据以一个错误终止的Observable

Observable.error(new Throwable("O__O"));

timer

在延迟一段给定的时间后发射一个简单的数字0

Observable.timer(1000, TimeUnit.MILLISECONDS)
              .subscribe(s -> System.out.println(s));

range

start:起始值
count:一个是范围的数据的数目。0不发送，负数异常

Observable.range(5, 3)
        //输出 5,6,7
        .subscribe(s -> System.out.println(s));

intervalRange

start,count:同range
initialDelay 发送第一个值的延迟时间
period 每两个发射物的间隔时间
unit,scheduler 额你懂的

Observable.intervalRange(5, 100, 3000, 100,
                TimeUnit.MILLISECONDS, Schedulers.io())
                .subscribe(s -> System.out.println(s));

interval

相当于intervalRange的start=0
period 这个值一旦设定后是不可变化的

//period 以后的美每次间隔 这个值一旦设定后是不可变化的  所以 count方法无效的！
int[] s = new int[]{0};
 Observable.interval(3000, 100 + count(s), TimeUnit.MILLISECONDS, Schedulers.io())
         .subscribe(s2 -> System.out.println(s2));
 private int count(int[] s) {
         int result = s[0] * 1000;
         s[0] = s[0] + 1;
         return result;
 }

defer

直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable

Observable.defer(() -> Observable.just("Love", "For", "You!"))
              .subscribe(s -> System.out.println(s));

from系列

fromArray

Integer[] items = {0, 1, 2, 3, 4, 5};
       Observable.fromArray(items).subscribe(
               integer -> System.out.println(integer));

fromCallable

Observable.fromCallable(() -> Arrays.asList("hello", "gaga"))
                .subscribe(strings -> System.out.println(strings))

fromIterable

Observable.fromIterable(Arrays.<String>asList("one", "two", "three"))
             .subscribe(integer -> System.out.println(integer));

fromFuture

Observable.fromFuture(Observable.just(1).toFuture())
               .doOnComplete(() -> System.out.println("complete"))
               .subscribe();

过滤操作

elementAt

只发射第N项数据

<!-- 无默认值版本 -->
 Observable.just(1,2)
            .elementAt(0)
            .subscribe(o -> System.out.print(o ));//结果:1
<!-- 带默认值的变体版本 -->
Observable.range(0, 10)
//        如果索引值大于数据 项数，它会发射一个默认值(通过额外的参数指定)，而不是抛出异常。
//    但是如果你传递一 个负数索引值，它仍然会抛出一个 IndexOutOfBoundsException 异常。
                .elementAt(100, -100)
                .subscribe(o -> System.out.print(o + "\t"));

IgnoreElements

如果你不关心一个Observable发射的数据，但是希望在它完成时或遇到错误终止时收到通知

Observable.range(0, 10)
               .ignoreElements()
               .subscribe(() -> System.out.println("complete")
                       , throwable -> System.out.println("throwable"));

take系列

take

变体 count系列:只发射前面的N项数据

Observable.range(0,10)
               .take(3)
               .subscribe(o -> System.out.print(o + "\t"))

变体 time系列: 发射Observable开始的那段时间发射的数据

Observable.range(0,10)
          .take(100, TimeUnit.MILLISECONDS)
          .subscribe(o -> System.out.print(o + "\t"));

takeLast

变体 count系列:只发射后面的N项数据

Observable.range(0,10)
                    .takeLast(3)
                    .subscribe(o -> System.out.print(o + "\t"));

变体 time系列: 发射在原始Observable的生命周期内最后一段时间内发射的数据

Observable.range(0,10)
               .takeLast(100, TimeUnit.MILLISECONDS)
               .subscribe(o -> System.out.print(o + "\t"));

takeUntil

发送complete的结束条件 当然发送结束之前也会包括这个值

Observable.just(2,3,4,5)
        //发送complete的结束条件 当然发送结束之前也会包括这个值
        .takeUntil(integer ->  integer>3)
        .subscribe(o -> System.out.print(o + "\t"));//2,3,4

takeWhile

当不满足这个条件 会发送结束 不会包括这个值

Observable.just(2,3,4,5)
        //当不满足这个条件 会发送结束 不会包括这个值
        .takeWhile(integer ->integer<=4 )
        .subscribe(o -> System.out.print(o + "\t"));//2,3,4

skip系列

skip

变体 count系列:丢弃Observable发射的前N项数据

Observable.range(0,5)
               .skip(3)
               .subscribe(o -> System.out.print(o + "\t"));

变体 time系列:丢弃原始Observable开始的那段时间发射的数据

Observable.range(0,5)
               .skip(3)
               .subscribe(o -> System.out.print(o + "\t"));

skipLast

变体 count系列:丢弃Observable发射的前N项数据

Observable.range(0,5)
               .skipLast(3)
               .subscribe(o -> System.out.print(o + "\t"));

变体 time系列:丢弃在原始Observable的生命周期内最后一段时间内发射的数据

Observable.range(0,10)
             .skipLast(100, TimeUnit.MILLISECONDS)
             .subscribe(o -> System.out.print(o + "\t"));

distinct

去重

keySelector:这个函数根据原始Observable发射的数据项产生一个 Key，然后，比较这些Key而不是数据本身，来判定两个数据是否是不同的

Observable.just(1, 2, 1, 2, 3)
            //这个函数根据原始Observable发射的数据项产生一个 Key，
            // 然后，比较这些Key而不是数据本身，来判定两个数据是否是不同的
            .distinct(integer -> Math.random())
            .subscribe(o -> System.out.print(o + "\t"));
日志:
原因 key不同 所以当做数据不同处理
1   2   1   2   3

无参版本就是内部实现了的keySelector通过生成的key就是value本身

Observable.just(1, 2, 1, 2, 3)
             .distinct()
             .subscribe(o -> System.out.print(o + "\t"));
 日志:
 1   2   3

distinctUntilChanged

(相邻去重):它只判定一个数据和它的直接前驱是 否是不同的
其他概念与distinct一样

throttleWithTimeout/debounce

操作符会过滤掉发射速率过快的数据项
throttleWithTimeout/debounce： 含义相同
如果发送数据后 指定时间段内没有新数据的话 。则发送这条
如果有新数据 则以这个新数据作为将要发送的数据项，并且重置这个时间段，重新计时。

  Observable.create(e -> {
            e.onNext("onNext 0");
            Thread.sleep(100);
            e.onNext("onNext 1");
            Thread.sleep(230);
            e.onNext("onNext 2");
            Thread.sleep(300);
            e.onNext("onNext 3");
            Thread.sleep(400);
            e.onNext("onNext 4");
            Thread.sleep(500);
            e.onNext("onNext 5");
            e.onNext("onNext 6");
        })
                .debounce(330, TimeUnit.MILLISECONDS)
//                .throttleWithTimeout(330, TimeUnit.MILLISECONDS)
                .subscribeOn(Schedulers.newThread())
                .observeOn(Schedulers.newThread())
                .subscribe(o -> System.out.println(o));//结果 3 4 6

filter

只发射通过了谓词测试的数据项

Observable.range(0, 10)
        //过滤掉false的元素
        .filter(integer -> integer % 2 == 0)
        .subscribe(o -> System.out.print(o + "\t"));

ofType

ofType 是 filter 操作符的一个特殊形式。它过滤一个Observable只返回指定类型的数据

Observable.just(0, "what?", 1, "String", 3)
             //ofType 是 filter 操作符的一个特殊形式。它过滤一个Observable只返回指定类型的数据。
             .ofType(String.class)
             .subscribe(o -> System.out.print(o + "\t"));

first

只发射第一项(或者满足某个条件的第一项)数 感觉和take(1) elementAt(0)差不多

Observable.range(0, 10)
          //如果元数据没有发送  则有发送默认值
          .first(-1)
          .subscribe(o -> System.out.print(o + "\t"));

last

只发射最后一项(或者满足某个条件的最后一项)数据 感觉和takeLast(1)差不多

Observable.empty()
              //如果元数据没有发送  则有发送默认值
              .last(-1)
              .subscribe(o -> System.out.print(o + "\t"));

sample/throttleLast

周期采样后 发送最后的数据

throttleFirst

周期采样 的第一条数据 发送
注意: 如果是已经被发送过的 则不会继续发送

 Observable.create(e -> {
            e.onNext("onNext 0");
            Thread.sleep(100);
            e.onNext("onNext 1");
            Thread.sleep(50);
            e.onNext("onNext 2");
            Thread.sleep(70);
            e.onNext("onNext 3");
            Thread.sleep(200);
            e.onNext("onNext 4");
            e.onNext("onNext 5");
        })
                .subscribeOn(Schedulers.newThread())
                .observeOn(Schedulers.newThread())
                <!--  结果 : onNext 2 onNext 3    onNext 5    -->
                .sample(200, TimeUnit.MILLISECONDS,Schedulers.newThread())
                <!--  结果 : onNext 2 onNext 3    onNext 5    -->
//                .throttleLast(200, TimeUnit.MILLISECONDS,Schedulers.newThread())
                <!--  结果 : onNext 0 onNext 3    onNext 4    -->
//                .throttleFirst(200, TimeUnit.MILLISECONDS,Schedulers.newThread())
                .subscribe(o -> System.out.print(o + "\t"));

Typist夫少

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
RxJava2总结之操作详解(一)

目录目录创建操作createjustemptynevererrortimerrangeintervalRangeintervaldeferfrom系列fromArrayfromCallablefromIterablefromFuture过滤操作elementAtIgnoreElementstake系列taketakeLasttakeUntiltakeW
复制链接

扫一扫