本教程基于RxJava1.x版本进行全面讲解，后续课程将陆续更新,敬请关注…
以下的函数都是用来创建被观察者Observable的函数。我们可以根据需要创建对应的函数。
- Create - 最原始的Observable创建函数
- Defer - 创建订阅后才创建的Observable
- Empty/Never/Throw - 创建不发送数据/以发送一个异常的数据的bservable
- Just - 创建发送1-9个值的Observable
- From - 创建发送一个队列的Observable
- Interval&Timer -创建一个类似定时器的Observable
- Range - 创建一个发送一个特定整数型的Observable
- Repeat - 创建一个设定重复发送次数的Observable
1.Create
你可以使用Create操作符从头开始创建一个Observable，给这个操作符传递一个接受观察者作为参数的函数，编写这个函数让它的行为表现为一个Observable–恰当的调用观察者的onNext，onError和onCompleted方法。
一个形式正确的有限Observable必须尝试调用观察者的onCompleted正好一次或者它的onError正好一次，而且此后不能再调用观察者的任何其它方法。
建议你在传递给create方法的函数中检查观察者的isUnsubscribed状态，以便在没有观察者的时候，让你的Observable停止发射数据或者做昂贵的运算。
示例代码：
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.
2.Defer
直到有观察者订阅时才创建Observable，并且为每个观察者创建一个新的Observable。
Defer操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个Observable，事实上每个订阅者获取的是它们自己的单独的数据序列。
代码如下：
Observable<String> defer = Observable.defer(new Func0<Observable<String>>() {
//当observable被创建的时候顺便调用observable内部的call()方法并在方法中发送消息
//每subscribe()就会在call()中返回一个新的实例对象
@Override
public Observable<String> call() {
Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello Android !");
}
});
return observable;
}
});
defer.subscribe(new Action1<String>() {
@Override
public void call(String s) {
}
});
defer.subscribe(new Action1<String>() {
@Override
public void call(String s) {
}
});
3.Empty/Never/Throw
Empty
创建一个不发射任何数据但是正常终止的Observable
Never
创建一个不发射数据也不终止的Observable
Throw
创建一个不发射数据以一个错误终止的Observable
这三个操作符生成的Observable行为非常特殊和受限。测试的时候很有用，有时候也用于结合其它的Observables，或者作为其它需要Observable的操作符的参数。
RxJava将这些操作符实现为 empty，never和error。error操作符需要一个Throwable参数，你的Observable会以此终止。这些操作符默认不在任何特定的调度器上执行，但是empty和error有一个可选参数是Scheduler，如果你传递了Scheduler参数，它们会在这个调度器上发送通知。
4.Just
如果被观察者想发射一个数据给观察者,那么代码是这样：
Observable
.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("hello Android");
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, "call: "+s);
}
});
上面的代码如想发送数据 首先要实现Observable.OnSubscribe接口，我们可以使用just函数代替。示例代码如下：
Observable
.just("hello Android")
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, "call: "+s);
}
});
输出:
onNext: hello Android
Sequence complete.
Just将单个数据转换为发射那个数据的Observable。
类似的函数有：
- just(T t1);
- just(T t1,T t2);
- just(T t1,T t2,T t3);
- just(T t1,T t2,T t3,T t4);
- just(T t1,T t2,T t3,T t4,T t5);
- …
RxJava将这个操作符实现为just函数，它接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable。
5.From
相比于发送一个到9个数据的just函数，From函数发送一个队列的数据，输出的长度无限。
学校开了一个兴趣班，开学班里来了几个同学。下面就是同学类的定义：
public static class Student { public String name; public int age; public Student(String name, int age) { this.name = name; this.age = age; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + '}'; } }这里创建一个集合 用来存储每个同学的信息。
private ArrayList initPersons() { ArrayList<Student> persons = new ArrayList<>(); persons.add(new Student("张三", 16)); persons.add(new Student("李四", 17)); persons.add(new Student("王二麻子", 18)); return persons; }接下来老师点评 每个都要喊一声到，这里通过打印来说明每个同学的签到情况。
ArrayList persons = initPersons(); for (int i = 0; i < persons.size(); i++) { //打印每个同学 Log.i(TAG,persons.get(i).toString()); }
RxJava这样转换：
//1.定义被观察者,用来发送一个队列的事件
Observable<Student> observable = Observable.from(persons);
//2.当开始订阅的时候 接收被观察者发送过来的一系列事件
observable.subscribe(new Action1<Student>() {
@Override
public void call(Student student) {
Log.i(TAG, "call: "+student.toString());
}
});
6.Interval&Timer
创建一个按固定时间间隔发射整数序列的Observable。
RxJava将这个操作符实现为interval方法。它接受一个表示时间间隔的参数和一个表示时间单位的参数。
//3000毫米发送一个请求 该请求包含了一个自增长的整数型变量
Observable<Long> observable = Observable.interval(3000, TimeUnit.MILLISECONDS, Schedulers.io());
observable.subscribe(new Action1<Long>() {
@Override
public void call(Long i) {
// such as printf RxIoScheduler-2call: 685
Log.i(TAG, Thread.currentThread().getName()+"call: "+i);
}
});
输出：
com.m520it.rxjava I/IT520: RxIoScheduler-2call: 0
com.m520it.rxjava I/IT520: RxIoScheduler-2call: 1
com.m520it.rxjava I/IT520: RxIoScheduler-2call: 2
com.m520it.rxjava I/IT520: RxIoScheduler-2call: 3
...
上面的代码在子线程中根据某种时间间隔不断打印数据。该操作类似于Timer任务，你也可以认为它是用来替换Timer定时器的。
类似的函数还有timer()函数。
Observable<Long> timer = Observable.timer(3000, 2000, TimeUnit.MILLISECONDS);
timer.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
Log.i(TAG, "call: "+aLong);
}
});
7.Range
创建一个发射特定整数序列的Observable。
Range操作符发射一个范围内的有序整数序列，你可以指定范围的起始和长度。
比如下面这个班级的所有学生都在一个集合里，现在要打印出来，可以是这样的：
private ArrayList initPersons() {
ArrayList<Student> persons = new ArrayList<>();
persons.add(new Student("张三", 16));
persons.add(new Student("李四", 17));
persons.add(new Student("王二麻子", 18));
return persons;
}
final ArrayList<Student> students = initPersons();
//这里发射一个起始值0，长度students.size()的索引 用来遍历队列
Observable
.range(0,students.size())
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer index) {
Log.i(TAG, "call: "+students.get(index));
}
});
8.Repeat
创建一个发射特定数据重复多次的Observable
Repeat重复地发射数据。某些实现允许你重复的发射某个数据序列，还有一些允许你限制重复的次数。
//设置重复发送3次
Observable<String> observable = Observable.just("Hello Android").repeat(3);
Action1<String> action1 = new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, "call: " + s);
}
};
observable.subscribe(action1);