Observable（被观察者，发射器）发送数据：
just：发送单个的数据；
Observable.just("cui","chen","bo")
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: "+s);
}
});
Log:
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: accept: cui
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: accept: chen
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: accept: bo
fromIterable：发送集合类型的数据；
List<String> datas = Arrays.asList("H","W","Rx");
Observable.fromIterable(datas)
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String value) {
Log.i(TAG, "onNext: "+value);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
Log:
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: onNext: H
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: onNext: W
04-27 22:44:05.988 7317-7317/com.ccb.pactera.rxdemo I/MainActivity: onNext: Rx
数据转换：
map：一对一的转换；
final Integer icon = R.mipmap.ic_launcher_round;
//数据转换
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(icon);
e.onComplete();
}
})
.map(new Function<Integer, Drawable>() {
@Override
public Drawable apply(Integer integer) throws Exception {
return getResources().getDrawable(integer);
}
})
.subscribe(new Observer<Drawable>() {
@Override
public void onSubscribe(Disposable d) { } @Override
public void onNext(Drawable value) {
ImageView iv = new ImageView(MainActivity.this);
iv.setImageDrawable(value);
} @Override
public void onError(Throwable e) { } @Override
public void onComplete() { }
});
flatMap：一对多的转换；
public class Course {
private String name;
private int id;
public Course(String name, int id) {
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
public class Student {
private String name;
private ArrayList<Course> courses;
public Student(String name, ArrayList<Course> courses) {
this.name = name;
this.courses = courses;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ArrayList<Course> getCourses() {
return courses;
}
public void setCourses(ArrayList<Course> courses) {
this.courses = courses;
}
}
Course yuwen = new Course("语文", 1);
Course shuxue = new Course("数学", 2);
Course yingyu = new Course("英文", 3);
Course lishi = new Course("历史", 4);
Course zhengzhi = new Course("政治", 5);
Course xila = new Course("希腊语", 6);
ArrayList<Course> course1 = new ArrayList<>();
course1.add(yuwen);
course1.add(shuxue);
course1.add(yingyu);
course1.add(lishi);
course1.add(zhengzhi);
course1.add(xila);
Student zhangsan = new Student("zhangsan", course1);
Observable.just(zhangsan)
.flatMap(new Function<Student, ObservableSource<Course>>() {
@Override
public ObservableSource<Course> apply(Student student) throws Exception {
return Observable.fromIterable(student.getCourses());
}
})
.subscribe(new Consumer<Course>() {
@Override
public void accept(Course course) throws Exception {
Log.i(TAG, "accept: "+course.getName());
}
});
Log：
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 语文
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 数学
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 英文
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 历史
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 政治
04-27 23:12:50.084 11652-11652/? I/MainActivity: accept: 希腊语
线程切换：
默认：
Observable.just("CCB")
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: ---"+s+"--线程--"+Thread.currentThread());
}
});
Log：
MainActivity: accept: ---CCB--线程--main （主线程）；
添加subscribeOn(Schedulers.io());后；Log：MainActivity: accept: ---CCB--线程--RxCachedThreadScheduler-1 （子线程）
Observable.just("CCB")
.subscribeOn(Schedulers.io())
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: ---"+s+"--线程--"+Thread.currentThread());
}
});
再添加： .observeOn(AndroidSchedulers.mainThread())后；log：MainActivity: accept: ---CCB--线程--main （主线程）；
Observable.just("CCB")
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: ---"+s+"--线程--"+Thread.currentThread());
}
});
这样我们就可以把一些耗时的操作（加载图片、网络请求）放在子线程，然后更新界面的时候再切换到主线程；各种线程间的切换只需要一行代码就可以搞定，而且链式调用，思路清晰；
* Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
* Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
* Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
* AndroidSchedulers.mainThread(): Android专用,它指定的操作将在 Android 主线程运行。
* 指定线程的方法:
* Observable.subscribeOn():指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程
* Observable.observeOn():指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。
OK！Rxjava的线程切换以及数据转换就说完了。