RxJava2总结之操作详解(一)

目录
创建操作
create
just
empty
never
error
timer
range
intervalRange
interval
defer
from系列
fromArray
fromCallable
fromIterable
fromFuture
过滤操作
elementAt
IgnoreElements
take系列
take
takeLast
takeUntil
takeWhile
skip系列
skip
skipLast
distinct
distinctUntilChanged
throttleWithTimeoutdebounce
filter
ofType
first
last
samplethrottleLast
throttleFirst
创建操作

create

创建一个具有发射能力的Observable 
1
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
1
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 
1
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项数据
1
<!-- 无默认值版本 -->
 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

只发射通过了谓词测试的数据项
1
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)差不多
1
Observable.range(0, 10)
          //如果元数据没有发送  则有发送默认值
          .first(-1)
          .subscribe(o -> System.out.print(o + "\t"));
last

只发射最后一项(或者满足某个条件的最后一项)数据 感觉和takeLast(1)差不多
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"));