RxJava进阶一（创建类操作符）

发表于 | 分类于 ， | 阅读次数
前面已经对RxJava原理进行介绍，相信大家对于RXJava已经有了初步的认识，但是在具体使用方面还有些懵懂，从这篇开始详细介绍下RxJava的具体使用，首先介绍下RXJava的创建操作符~

RxJava进阶一（创建类操作符）
RxJava进阶二（转换类操作符）
RxJava进阶三（过滤类操作符）
RxJava进阶四（组合类操作符）

前言

前面已经对RxJava原理进行介绍，相信大家对于RXJava已经有了初步的认识，但是在具体使用方面还有些懵懂，从这篇开始详细介绍下RxJava的具体使用，首先介绍下RXJava的创建操作符~

操作符总览

create、just、from、defer、range、interval、timer、empty、never 、error、repeat、delay…

具体使用介绍

create

create是RxJava最基本的创建操作符了，使用也是最简单的~

代码调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> subscriber) {
        subscriber.onNext(1);
        subscriber.onNext(2);
        subscriber.onNext(3);
        subscriber.onNext(4);
        subscriber.onCompleted();
    }
}).subscribe(new Subscriber<Integer>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("Error = " + e.getMessage());
    }
    @Override
    public void onNext(Integer integer) {
        System.out.println("integer = " + integer);
    }
});

运行结果如下

create操作符运行结果

just

just操作符将某个对象转化为Observable对象，并且将其发射出去，可以使一个数字、一个字符串、数组、Iterate对象等，是一种非常快捷的创建Observable对象的方法~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
List<String> stringList = new ArrayList<>();
stringList.add("one");
stringList.add("two");
stringList.add("three");
Observable.just(stringList).subscribe(new Subscriber<List<String>>() {
    @Override
    public void onCompleted() {
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onNext(List<String> strings) {
    }
});

从代码很清楚的看到，在onNext方法中输出的是 **List


**

对象。

from

from操作符用来将某个对象转化为Observable对象，并且依次将其内容发射出去，from的接收值可以是集合或者数组，这个类似于just，但是just会将这个对象整个发射出去。比如说一个含有3个元素的集合，from会将集合分成3次发射，而使用just会发射一次来将整个的数组发射出去~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
List<String> stringList = new ArrayList<>();
stringList.add("one");
stringList.add("two");
stringList.add("three");
Observable.from(stringList).subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }
    @Override
    public void onError(Throwable e) {
        System.out.println("Error = " + e.getMessage());
    }
    @Override
    public void onNext(String s) {
        System.out.println("String = " + s);
    }
});

很明显，from对集合或数组对象进行了遍历输出。

defer

Defer操作符只有当有Subscriber来订阅的时候才会创建一个新的Observable对象,也就是说每次订阅都会得到一个刚创建的最新的Observable对象，这可以确保Observable对象里的数据是最新的，而just则没有创建新的Observable对象，这样说可能并不利于大家消化，看下边与just对比示例~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Action1<String> action1 = new Action1<String>() {
    @Override
    public void call(String s) {
        System.out.println(s);
    }
};
// defer
Observable<String> defer = Observable.defer(new Func0<Observable<String>>() {
    @Override
    public Observable<String> call() {
        Object o = new Object();
        return Observable.just("defer : hashCode  = " + o.hashCode());
    }
});
defer.subscribe(action1);
defer.subscribe(action1);
defer.subscribe(action1);
// just
Observable<String> just = Observable.just("just : hashCode  = " + new Object().hashCode());
just.subscribe(action1);
just.subscribe(action1);
just.subscribe(action1);

输出结果

defer操作符运行结果

从输出结果可以看出来，defer订阅了三次，但是每次的地址值都发生了变化，而just则三次的地址值是同样的，从而验证了上面的结论。

range

Range操作符根据输入的初始值【initial】和数量【number】发射number次、大于等于initial的值~

1
2
3
4
5
6
Observable.range(100, 5).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println(integer);
    }
});

range操作符运行结果

interval

Interval所创建的Observable对象会从0开始，每隔固定的时间发射一个数字，需要注意的是这个对象是运行在computation Scheduler,所以要更新UI需要在主线程中进行订阅~

1
2
3
4
5
6
7
8
9
Observable
        .interval(1, TimeUnit.SECONDS)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                System.out.println(aLong);
            }
        });

输出结果

interval操作符运行结果

timer

Timer会在指定时间后发射一个数字0，注意其也是运行在computation Scheduler~

1
2
3
4
5
6
Observable
        .timer(2, TimeUnit.SECONDS)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(aLong -> {
            // 替代timertask与handler延迟，可以在这跳转主界面
        });

下面有几个不常用的创建操作符，还是简单介绍下吧~

empty

创建一个Observable不发射任何数据、而是立即调用onCompleted方法终止~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Observable<String> empty = Observable.empty();
empty.subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onNext(String s) {
        System.out.println("onNext");
    }
});

输出结果

empty操作符运行结果

never

创建一个Observable不发射任何数据、也不给订阅ta的Observer发出任何通知~

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Observable<String> never = Observable.never();
never.subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }
    @Override
    public void onError(Throwable e) {
        System.out.println(e.getMessage());
    }
    @Override
    public void onNext(String s) {
        System.out.println("onNext");
    }
});

输出结果

never操作符运行结果

error

返回一个Observable，当有Observer订阅ta时直接调用Observer的onError方法终止

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Observable<String> error = Observable.error(new Throwable("Observable.error"));
error.subscribe(new Subscriber<String>() {
    @Override
    public void onCompleted() {
        System.out.println("onCompleted");
    }
    @Override
    public void onError(Throwable e) {
        System.out.println(e.getMessage());
    }
    @Override
    public void onNext(String s) {
        System.out.println("onNext");
    }
});

输出结果

error操作符运行结果

接下来有两个不是创建类操作符，但是行为能力与创建类操作符非常相似，故在此介绍下~

repeat

Repeat会将一个Observable对象重复发射，接收值是发射的次数，依然订阅在 computation Scheduler~

1
2
3
4
5
6
Observable.just(1).repeat(10).subscribe(new Action1<Integer>() {
    @Override
    public void call(Integer integer) {
        System.out.println(integer);
    }
});

输出结果

repeat操作符运行结果

delay

功能与timer操作符一样，但是delay用于在事件中，可以延迟发送事件中的某一次发送~

1
2
3
4
5
6
Observable.just(1).delay(2,TimeUnit.SECONDS).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                System.out.println(integer);
            }
        });

结语

创建类操作符，就简单介绍到这里，希望能够对同学有所帮助，谢谢~