*map家族

RxJava提供了几个mapping函数：map(),flatMap(),concatMap(),flatMapIterable()以及switchMap().所有这些函数都作用于一个可观测序列，然后变换它发射的值，最后用一种新的形式返回它们。让我们用合适的“真实世界”的例子一个个的学习下。

Map

RxJava的map函数接收一个指定的Func对象然后将它应用到每一个由Observable发射的值上。下图展示了如何将一个乘法函数应用到每个发出的值上以此创建一个新的Observable来发射转换的数据。

*map家族 - 图1

考虑下我们已安装的应用列表。我们怎么才能够显示同样的列表，但是又要所有的名字都小写呢？

我们的loadList()函数可以改成这样：

  1. private void loadList(List<AppInfo> apps) {
  2.     mRecyclerView.setVisibility(View.VISIBLE);
  3.     Observable.from(apps)
  4.         .map(new Func1<AppInfo,AppInfo>(){
  5.             @Override
  6.             public Appinfo call(AppInfo appInfo){
  7.                 String currentName = appInfo.getName();
  8.                 String lowerCaseName = currentName.toLowerCase();
  9.                 appInfo.setName(lowerCaseName);
  10.                 return appInfo;
  11.             }
  12.         })
  13.         .subscribe(new Observer<AppInfo>() {
  15.             @Override
  16.             public void onCompleted() {
  17.                 mSwipeRefreshLayout.setRefreshing(false);
  18.             }
  20.             @Override
  21.             public void onError(Throwable e) {
  22.                 Toast.makeText(getActivity(), "Something went wrong!", Toast.LENGTH_SHORT).show();
  23.                 mSwipeRefreshLayout.setRefreshing(false);
  24.             }
  26.             @Override
  27.             public void onNext(AppInfo appInfo) {
  28.                 mAddedApps.add(appInfo); 
  29.                 mAdapter.addApplication(mAddedApps.size() - 1,appInfo);
  30.             }
  31.         });
  32. }

正如你看到的，像往常一样创建我们发射的Observable之后，我们追加一个map调用，我们创建一个简单的函数来更新AppInfo对象并提供一个名字小写的新版本给观察者。

FlatMap

在复杂的场景中，我们有一个这样的Observable：它发射一个数据序列，这些数据本身也可以发射Observable。RxJava的flatMap()函数提供一种铺平序列的方式，然后合并这些Observables发射的数据，最后将合并后的结果作为最终的Observable。

*map家族 - 图2

当我们在处理可能有大量的Observables时，重要是记住任何一个Observables发生错误的情况，flatMap()将会触发它自己的onError()函数并放弃整个链。

重要的一点提示是关于合并部分：它允许交叉。正如上图所示，这意味着flatMap()不能够保证在最终生成的Observable中源Observables确切的发射顺序。

ConcatMap

RxJava的concatMap()函数解决了flatMap()的交叉问题，提供了一种能够把发射的值连续在一起的铺平函数，而不是合并它们，如下图所示：

*map家族 - 图3

FlatMapIterable

作为*map家族的一员，flatMapInterable()和flatMap()很像。仅有的本质不同是它将源数据两两结成对并生成Iterable，而不是原始数据项和生成的Observables。

*map家族 - 图4

SwitchMap

如下图所示，switchMap()和flatMap()很像，除了一点：每当源Observable发射一个新的数据项（Observable）时，它将取消订阅并停止监视之前那个数据项产生的Observable，并开始监视当前发射的这一个。

*map家族 - 图5

Scan

RxJava的scan()函数可以看做是一个累积函数。scan()函数对原始Observable发射的每一项数据都应用一个函数，计算出函数的结果值，并将该值填充回可观测序列，等待和下一次发射的数据一起使用。

作为一个通用的例子，给出一个累加器：

  1. Observable.just(1,2,3,4,5)
  2.         .scan((sum,item) -> sum + item)
  3.         .subscribe(new Subscriber<Integer>() {
  4.             @Override
  5.             public void onCompleted() {
  6.                 Log.d("RXJAVA", "Sequence completed.");
  7.             }
  9.             @Override
  10.             public void onError(Throwable e) {
  11.                 Log.e("RXJAVA", "Something went south!");
  12.             }
  14.             @Override
  15.             public void onNext(Integer item) {
  16.                 Log.d("RXJAVA", "item is: " + item);
  17.             }
  18.         });

我们得到的结果是：

  1. RXJAVA: item is: 1
  2. RXJAVA: item is: 3
  3. RXJAVA: item is: 6
  4. RXJAVA: item is: 10
  5. RXJAVA: item is: 15
  6. RXJAVA: Sequence completed.

我们也可以创建一个新版本的loadList()函数用来比较每个安装应用的名字从而创建一个名字长度递增的列表。

  1. private void loadList(List<AppInfo> apps) {
  2.     mRecyclerView.setVisibility(View.VISIBLE);
  3.     Observable.from(apps)
  4.             .scan((appInfo,appInfo2) -> {
  5.                 if(appInfo.getName().length > appInfo2.getName().length()){
  6.                     return appInfo;
  7.                 } else {
  8.                     return appInfo2;
  9.                 }
  10.             })
  11.             .distinct()
  12.             .subscribe(new Observer<AppInfo>() {
  14.                 @Override
  15.                 public void onCompleted() {
  16.                     mSwipeRefreshLayout.setRefreshing(false);
  17.                 }
  19.                 @Override
  20.                 public void onError(Throwable e) {
  21.                     Toast.makeText(getActivity(), "Something went wrong!", Toast.LENGTH_SHORT).show();
  22.                     mSwipeRefreshLayout.setRefreshing(false);
  23.                 }
  25.                 @Override
  26.                 public void onNext(AppInfo appInfo) {
  27.                     mAddedApps.add(appInfo); 
  28.                     mAdapter.addApplication(mAddedApps.size() - 1,appInfo);
  29.                 }
  30.             });
  31. }

结果如下：

*map家族 - 图6

有一个scan()函数的变体，它用初始值作为第一个发射的值，方法签名看起来像：scan(R,Func2)，如下图中的例子这样：

*map家族 - 图7