您的位置：首页 > 编程语言 > Java开发

RxJava操作符－创建型

2016-06-11 10:59 393 查看

操作符类型

创建操作

变换操作

过滤操作

组合操作

错误处理

辅助操作

条件和布尔操作

算术和聚合操作

连接操作

转换操作

创建操作

create

你可以使用create操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数，编写这个函数让它的行为表现为一个Observable–恰当的调用观察者的onNext，onError和onCompleted方法。

一个形式正确的有限Observable必须尝试调用观察者的onCompleted正好一次或者它的onError正好一次，而且此后不能再调用观察者的任何其它方法。

create操作符是所有创建型操作符的“根”，也就是说其他创建型操作符最后都是通过create操作符来创建Observable的，其流程图例如下：

[b]示例代码[/b]

Observable.create(new Observable.OnSubscribe<Integer>() {
@Override
public void call(Subscriber<? super Integer> observer) {
try {
if (!observer.isUnsubscribed()) {
for (int i = 1; i < 5; i++) {
observer.onNext(i);
}
observer.onCompleted();
}
} catch (Exception e) {
observer.onError(e);
}
}
} ).subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}

@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}

@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});

运行结果如下：

Next: 1

Next: 2

Next: 3

Next: 4

Sequence complete.

在使用create操作符时，最好要在回调的call函数中增加isUnsubscribed的判断，以便在subscriber在取消订阅时不会再执行call函数中相关代码逻辑，从而避免导致一些意想不到的错误出现。

from

将其它种类(只局限于Future、Iterable和数组？)的对象和数据类型转换为Observable。

from操作符可以转换Future、Iterable和数组。对于Iterable和数组，产生的Observable会发射Iterable或数组的每一项数据。对于Future，它会发射Future.get()方法返回的单个数据。from方法有一个可接受两个可选参数的版本，分别指定超时时长和时间单位。如果过了指定的时长Future还没有返回一个值，这个Observable会发射错误通知并终止。

from默认不在任何特定的调度器上执行。然而你可以将Scheduler作为可选的第二个参数传递给Observable，它会在那个调度器上管理这个Future。

from(array)

from(Iterable)

from(Future)

from(Future,Scheduler)

from(Future,timeout, timeUnit)

其流程图例如下：

[b]示例代码[/b]

Integer[] items = { 0, 1, 2, 3, 4, 5 };
Observable myObservable = Observable.from(items);

myObservable.subscribe(
new Action1<Integer>() {
@Override
public void call(Integer item) {
System.out.println(item);
}
},
new Action1<Throwable>() {
@Override
public void call(Throwable error) {
System.out.println("Error encountered: " + error.getMessage());
}
},
new Action0() {
@Override
public void call() {
System.out.println("Sequence complete");
}
}
);

运行结果如下：

0

1

2

3

4

5

Sequence complete

just

just将单个数据转换为发射那个数据的Observable。

just类似于

from

，但是

from

会将数组或Iterable的素具取出然后逐个发射，而just只是简单的原样发射，将数组或Iterable当做单个数据。

注意：如果你传递null给just，它会返回一个发射null值的Observable。不要误认为它会返回一个空Observable（完全不发射任何数据的Observable），如果需要空Observable你应该使用empty操作符。

它接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable。

其流程图例如下：

[b]示例代码[/b]

Observable.just(1, 2, 3)
.subscribe(new Subscriber<Integer>() {
@Override
public void onNext(Integer item) {
System.out.println("Next: " + item);
}

@Override
public void onError(Throwable error) {
System.err.println("Error: " + error.getMessage());
}

@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}
});

运行结果如下：

Next: 1

Next: 2

Next: 3

Sequence complete.

defer

defer操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。

defer操作符能够保证Observable的状态是最新的。

这个操作符接受一个你选择的Observable工厂函数作为单个参数。这个函数没有参数，返回一个Observable。

de
4000
fer(Func0)

defer方法默认不在任何特定的调度器上执行。

其流程图例如下：

[b]defer操作符和just操作符运行结果比较示例程序[/b]

i=10;
Observable justObservable = Observable.just(i);
i=12;
Observable deferObservable = Observable.defer(new Func0<Observable<Object>>() {
@Override
public Observable<Object> call() {
return Observable.just(i);
}
});
i=15;

justObservable.subscribe(new Subscriber() {
@Override
public void onCompleted() {

}

@Override
public void onError(Throwable e) {

}

@Override
public void onNext(Object o) {
System.out.println("just result:" + o.toString());
}
});

deferObservable.subscribe(new Subscriber() {
@Override
public void onCompleted() {

}

@Override
public void onError(Throwable e) {

}

@Override
public void onNext(Object o) {
System.out.println("defer result:" + o.toString());
}
});

运行结果如下：

just result:10

defer result:15

可以看到，just操作符是在创建Observable就进行了赋值操作，而defer是在订阅者订阅时才创建Observable，此时才进行真正的赋值操作。

timer

注：该操作符已经不建议使用了，因为一个名叫interval的操作符有同样的功能。

timer操作符创建定时发送数字的Observable，这里有两种情况：

[b]创建一个Observable，它在一个给定的延迟后发射一个特殊的值[/b]

timer返回一个Observable，它在延迟一段给定的时间后发射一个简单的数字0。

timer操作符默认在computation调度器上执行。有一个变体可以通过可选参数指定Scheduler。

timer(long,TimeUnit)

timer(long,TimeUnit,Scheduler)

其流程实例如下：

[b]创建一个Observable，每隔一段时间就产生一个数字，没有结束符，也就是是可以产生无限个连续的数字[/b]

timer(long,long,TimeUnit)

其流程实例如下：

[b]示例程序[/b]

//每隔两秒产生一个数字
Observable.timer(2, 2, TimeUnit.SECONDS).subscribe(new Subscriber<Long>() {
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}

@Override
public void onError(Throwable e) {
System.out.println("error:" + e.getMessage());
}

@Override
public void onNext(Long aLong) {
System.out.println("Next:" + aLong.toString());
}
});

运行结果如下：

Next:0

Next:1

Next:2

Next:3

……

interval

创建一个按固定时间间隔发射整数序列的Observable，它按固定的时间间隔发射一个无限递增的整数序列。这些数字从0开始，一次递增1直至无穷大。

interval(long,TimeUnit)

interval(long,TimeUnit,Scheduler)

interval(long,long,TimeUnit))

interval(long,long,TimeUnit,Scheduler)

interval默认在computation调度器上执行。你也可以传递一个可选的Scheduler参数来指定调度器。

其流程实例如下：

示例程序：interval操作符的实现效果跟上面的timer操作符的第二种情形一样。

range

创建一个发射特定整数序列的Observable，其发射一个范围内的有序整数序列，你可以指定范围的起始和长度。

它接受两个参数，一个是范围的起始值，一个是范围的数据的数目。如果你将第二个参数设为0，将导致Observable不发射任何数据（如果设置为负数，会抛异常）。

range默认不在任何特定的调度器上执行。有一个变体可以通过可选参数指定Scheduler。

range(int,int)

range(int,int,Scheduler)

其流程实例如下：

[b]示例程序[/b]

//产生从3开始，个数为10个的连续数字
Observable.range(3,10).subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}

@Override
public void onError(Throwable e) {
System.out.println("error:" + e.getMessage());
}

@Override
public void onNext(Integer i) {
System.out.println("Next:" + i.toString());
}
});

运行结果如下：

Next:3

Next:4

Next:5

Next:6

….

Next:12

Sequence complete.

repeat/repeatWhen

[b]
repeat
[/b]

repeat重复地发射数据。某些实现允许你重复的发射某个数据序列，还有一些允许你限制重复的次数。

它不是创建一个Observable，而是重复发射原始Observable的数据序列，发射次数或者是无限的，或者通过repeat(n)指定重复次数。

repeat操作符默认在trampoline调度器上执行。有一个变体可以通过可选参数指定Scheduler。

repeat()

repeat(long))

repeat(Scheduler))

repeat(long,Scheduler)

其流程实例如下：

[b]示例程序[/b]

//连续产生两组(3,4,5)的数字
Observable.range(3,3).repeat(2).subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}

@Override
public void onError(Throwable e) {
System.out.println("error:" + e.getMessage());
}

@Override
public void onNext(Integer i) {
System.out.println("Next:" + i.toString());
}
});

运行结果如下：

Next:3

Next:4

Next:5

Next:3

Next:4

Next:5

Sequence complete.

[b]
repeatWhen
[/b]

它不是缓存和重放原始Observable的数据序列，而是有条件的重新订阅和发射原来的Observable。

将原始Observable的终止通知（完成或错误）当做一个void数据传递给一个通知处理器，它以此来决定是否要重新订阅和发射原来的Observable。这个通知处理器就像一个Observable操作符，接受一个发射void通知的Observable为输入，返回一个发射void数据（意思是，重新订阅和发射原始Observable）或者直接终止（意思是，使用repeatWhen终止发射数据）的Observable。

repeatWhen操作符默认在trampoline调度器上执行。有一个变体可以通过可选参数指定Scheduler。

repeatWhen(Func1)

repeatWhen(Func1,Scheduler)

其流程实例如下：

[b]示例程序[/b]

Observable.just(1,2,3).repeatWhen(new Func1<Observable<? extends Void>, Observable<?>>() {
@Override
public Observable<?> call(Observable<? extends Void> observable) {
//重复3次
return observable.zipWith(Observable.range(1, 3), new Func2<Void, Integer, Integer>() {
@Override
public Integer call(Void aVoid, Integer integer) {
return integer;
}
}).flatMap(new Func1<Integer, Observable<?>>() {
@Override
public Observable<?> call(Integer integer) {
System.out.println("delay repeat the " + integer + " count");
//1秒钟重复一次
return Observable.timer(1, TimeUnit.SECONDS);
}
});
}
}).subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
System.out.println("Sequence complete.");
}

@Override
public void onError(Throwable e) {
System.err.println("Error: " + e.getMessage());
}

@Override
public void onNext(Integer value) {
System.out.println("Next:" + value);
}
});

运行结果如下：

Next:1

Next:2

Next:3

repeat the 1 count

Next:1

Next:2

Next:3

repeat the 2 count

Next:1

Next:2

Next:3

repeat the 3 count

Next:1

Next:2

Next:3

Sequence complete.

empty/never/error

这些操作符默认不在任何特定的调度器上执行，但是empty和error有一个可选参数是Scheduler，如果你传递了Scheduler参数，它们会在这个调度器上发送通知。

[b]
empty
[/b]

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

empty()

[b]
never
[/b]

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

never()

[b]
error
[/b]

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

error(java.lang.Throwable)

参考文章链接

http://blog.csdn.net/job_hesc/article/details/46242117

https://github.com/ReactiveX/RxJava/wiki

9e91

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签： RxJava-创建型

相关文章推荐

新的分享

章节导航

RxJava操作符 －创建型

操作符类型

创建操作

create

from

just

defer

timer

interval

range

repeat/repeatWhen

empty/never/error

RxJava操作符－创建型