共同点：
- 都是依赖FuncX(入参，返回值)进行转换（将一个类型依据程序逻辑转换成另一种类型，根据入参和返回值）
- 都能在转换后直接被subscribe
区别：
- map返回的是结果集，flatmap返回的是包含结果集的Observable（返回结果不同）
- map被订阅时每传递一个事件执行一次onNext方法，flatmap多用于多对多，一对多，再被转化为多个时，一般利用from/just进行一一分发，被订阅时将所有数据传递完毕汇总到一个Observable然后一一执行onNext方法（执行顺序不同）>>>>(如单纯用于一对一转换则和map相同)
- map只能单一转换，单一只的是只能一对一进行转换，指一个对象可以转化为另一个对象但是不能转换成对象数组（map返回结果集不能直接使用from/just再次进行事件分发，一旦转换成对象数组的话，再处理集合/数组的结果时需要利用for一一遍历取出，而使用RxJava就是为了剔除这样的嵌套结构，使得整体的逻辑性更强。）
flatmap既可以单一转换也可以一对多/多对多转换，flatmap要求返回Observable，因此可以再内部进行from/just的再次事件分发，一一取出单一对象（转换对象的能力不同）
eg.1-2:
```
Observable.just("a", "b", "c")
//使用map进行转换，参数1：转换前的类型，参数2：转换后的类型
.map(new Func1<String, String>() {
@Override
public String call(String i) {
String name = i;
Log.i("tag","map--1----"+i);
return name;
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i("tag","map--2----"+s);
tv.setText(s);
}
});
logcat信息
11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--1----a
11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--2----a
11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--1----b
11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--2----b
11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--1----c
11-23 10:24:31.350 12902-12902/com.example.seele.retrofit I/tag: map--2----c
--------------------------------------------------------------------------------
Observable.just("a", "b", "c")
.flatMap(
new Func1<String, Observable<String>>() {
@Override
public Observable<String> call(String s) {
Log.i("tag", "map--1----" + s);
return Observable.just(s + "!!!");
}
})
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i("tag", "map--2----" + s);
tv.setText(s);
}
});
logcat信息：
11-23 10:53:51.320 14442-14527/? I/tag: map--1----a
11-23 10:53:51.320 14442-14527/? I/tag: map--1----b
11-23 10:53:51.320 14442-14527/? I/tag: map--1----c
11-23 10:53:51.340 14442-14442/? I/tag: map--2----a!!!
11-23 10:53:51.340 14442-14442/? I/tag: map--2----b!!!
11-23 10:53:51.340 14442-14442/? I/tag: map--2----c!!!
eg.3:
打印所有学生所修的课程名（每个学生有多门课程）
如果使用map来实现的代码是这样的：
Action1<List<Course>> action1 = new Action1<List<Course>>() {
@Override
public void call(List<Course> courses) {
//遍历courses，输出cuouses的name
for (int i = 0; i < courses.size(); i++){
Log.i(TAG, courses.get(i).getName());
}
}
};
Observable.from(students)
.map(new Func1<Student, List<Course>>() {
@Override
public List<Course> call(Student student) {
//返回coursesList
return student.getCoursesList();
}
})
.subscribe(action1);
//来这里在订阅之前如果继续用map处理则只能得到每个学生的一门所修的课程，只能循环遍历
flatMap实现的代码是这样的：
Observable.from(students)
.flatMap(new Func1<Student, Observable<Course>>() {
@Override
public Observable<Course> call(Student student) {
return Observable.from(student.getCoursesList());
}
})
.subscribe(new Action1<Course>() {
@Override
public void call(Course course) {
Log.i(TAG, course.getName());
}
});
//首先一旦订阅，通过flatmap根据from将所有传递过来的student包装到另一个observable中，然后一一发送事件（student）执行return Observable.from(student.getCoursesList());
//一旦事件发送完毕调用call，一一执行
使用场景：
map适用于一对一转换，当然也可以配合flatmap进行适用
flatmap适用于一对多，多对多的场景
