RxJava操作符系列二（上）

在上篇文章RxJava操作符系列一我们介绍的操作符几乎都是创建被观察者的操作符，那么今天的这篇文章就介绍一下经常用到的转换操作符。话不多说，开始上车。

Map

该操作符是对原始Observable发射的每一项数据运用一个函数，然后返回一个发射这些结果的Observable。

例如我们有一个整形数组的数据，当大于5时输出为true，则代码实现

1. Integer[] integers = {0, 9, 6, 4, 8}; 
2.         Observable.from(integers).map(new Func1() { 
3.             @Override 
4.             public Boolean call(Integer integer) { 
5.                 Log.e(TAG, "call: "+integer); 
6.                 return (integer > 5); 
7.             } 
8.         }).subscribe(new Subscriber() { 
9.             @Override 
10.             public void onCompleted() { 
11.                 Log.e(TAG, "onCompleted: "); 
12.             } 
13.   
14.             @Override 
15.             public void onError(Throwable e) { 
16.                 Log.e(TAG, "onError: "); 
17.             } 
18.   
19.             @Override 
20.             public void onNext(Boolean aBoolean) { 
21.                 Log.e(TAG, "onNext: "+aBoolean); 
22.             } 
23.         });  

日志输出信息

1. call: 0 
2. onNext: false 
3. call: 9 
4. onNext: true 
5. call: 6 
6. onNext: true 
7. call: 4 
8. onNext: false 
9. call: 8 
10. onNext: true 
11. onCompleted:  

对于map,他可以将将数据源变换为你想要的类型，比如，你想获取有一个Student对象(里面age，name属性)那么我们可以通过map只获取name。接下来。我们再举个例子，我们根据一个图片路径获取图片并将图片设置到ImageView,然后将ImageView加的我们的布局中。

1. String path = Environment.getExternalStorageDirectory()+ File.separator+"aaa.jpg"; 
2.         Observable.just(path) 
3.                 .subscribeOn(Schedulers.io()) 
4.                 .map(new Func1() { 
5.                     @Override 
6.                     public Bitmap call(String s) { 
7.                         Bitmap bitmap = BitmapFactory.decodeFile(s); 
8.                         Log.e(TAG, "call: Bitmap"+bitmap); 
9.                         return bitmap; 
10.                     } 
11.                 }).map(new Func1() { 
12.             @Override 
13.             public ImageView call(Bitmap bitmap) { 
14.                 Log.e(TAG, "call: ImageView"); 
15.                 ImageView imageView = new ImageView(getActivity()); 
16.                 LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT); 
17.                 imageView.setLayoutParams(params); 
18.                 imageView.setImageBitmap(bitmap); 
19.                 return imageView; 
20.             } 
21.         }).observeOn(AndroidSchedulers.mainThread()) 
22.                 .subscribe(new Subscriber() { 
23.                     @Override 
24.                     public void onCompleted() { 
25.                         Log.e(TAG, "onCompleted: "); 
26.                     } 
27.                     @Override 
28.                     public void onError(Throwable e) { 
29.                         Log.e(TAG, "onError: "); 
30.                     } 
31.   
32.                     @Override 
33.                     public void onNext(ImageView imageView) { 
34.                         Log.e(TAG, "onNext: "); 
35.                         layout.addView(imageView); 
36.                     } 
37.                 });  

Cast

该操作符就是做一些强制类型转换操作的。例如，当我们在页面跳转时数据对象往往是序列化的，当我们在新的页面收到数据后就要强制转换为我们想要的类型。cast操作符也可以实现这样的功能。如下

1. Observable.just(serializable).cast(FileInfo.class).subscribe(new Subscriber() { 
2.             @Override 
3.             public void onCompleted() { 
4.                 Log.e(TAG, "onCompleted: " ); 
5.             } 
6.   
7.             @Override 
8.             public void onError(Throwable e) { 
9.                 Log.e(TAG, "onError: " ); 
10.             } 
11.   
12.             @Override 
13.             public void onNext(FileInfo fileInfo) { 
14.                 Log.e(TAG, "onNext: "+fileInfo.toString()); 
15.                 tv1.append("\n"+fileInfo.toString()); 
16.             } 
17.         });  

不过在该操作符实际用途并没有那么的广泛，很少用到，当然这个操作符也可以达到java 中instanceof相同的作用，用于类型检查，当不是该类型就会执行onError()方法。

FlatMap

该操作符与map操作符的区别是它将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable.

1. Integer[] integers = {1, 2, 3}; 
2.         Observable.from(integers).flatMap(new Func1>() { 
3.             @Override 
4.             public Observable call(final Integer integer) { 
5.                 return Observable.create(new Observable.OnSubscribe() { 
6.                     @Override 
7.                     public void call(Subscriber super String> subscriber) { 
8.                         Log.e(TAG, "call: FlatMap " + Thread.currentThread().getName()); 
9.                         try { 
10.                             Thread.sleep(200); 
11.                             subscriber.onNext(integer + 100 + " FlatMap"); 
12.                             subscriber.onCompleted(); 
13.                         } catch (InterruptedException e) { 
14.                             e.printStackTrace(); 
15.                             subscriber.onError(e); 
16.                         } 
17.                     } 
18.                 }).subscribeOn(Schedulers.newThread()); 
19.             } 
20.         }).observeOn(AndroidSchedulers.mainThread()) 
21.                 .subscribe(new Subscriber() { 
22.                     @Override 
23.                     public void onCompleted() { 
24.                         Log.e(TAG, "onCompleted: FlatMap"); 
25.                     } 
26.   
27.                     @Override 
28.                     public void onError(Throwable e) { 
29.                         Log.e(TAG, "onError: FlatMap"); 
30.                     } 
31.   
32.                     @Override 
33.                     public void onNext(String s) { 
34.                         Log.e(TAG, "onNext: FlatMap " + s); 
35.                     } 
36.                 });  

打印日志信息

1. call: FlatMap RxNewThreadScheduler-2 
2. call: FlatMap RxNewThreadScheduler-3 
3. call: FlatMap RxNewThreadScheduler-4 
4. onNext: FlatMap 101 FlatMap 
5. onNext: FlatMap 102 FlatMap 
6. onNext: FlatMap 103 FlatMap 
7. onCompleted: FlatMap  

ConcatMap

该操作符是类似于最简单版本的flatMap，但是它按次序连接而不是合并那些生成的Observables，然后产生自己的数据序列.将上述flatMap代码更改如下

1. Integer[] integers = {1, 2, 3}; 
2.         Observable.from(integers).concatMap(new Func1>() { 
3.             @Override 
4.             public Observable call(final Integer integer) { 
5.                 return Observable.create(new Observable.OnSubscribe() { 
6.                     @Override 
7.                     public void call(Subscriber super String> subscriber) { 
8.                         Log.e(TAG, "call:2 ConcatMap " + Thread.currentThread().getName()); 
9.                         try { 
10.                             Thread.sleep(200); 
11.                             subscriber.onNext(integer + 100 + " ConcatMap"); 
12.                             subscriber.onCompleted(); 
13.                         } catch (InterruptedException e) { 
14.                             e.printStackTrace(); 
15.                             subscriber.onError(e); 
16.                         } 
17.                     } 
18.                 }).subscribeOn(Schedulers.newThread()); 
19.             } 
20.         }).observeOn(AndroidSchedulers.mainThread()) 
21.                 .subscribe(new Subscriber() { 
22.                     @Override 
23.                     public void onCompleted() { 
24.                         Log.e(TAG, "onCompleted: ConcatMap"); 
25.                     } 
26.   
27.                     @Override 
28.                     public void onError(Throwable e) { 
29.                         Log.e(TAG, "onError: ConcatMap"); 
30.                     } 
31.   
32.                     @Override 
33.                     public void onNext(String s) { 
34.                         Log.e(TAG, "onNext: ConcatMap " +s); 
35.                     } 
36.                 });  

接下文

本文作者：佚名

来源：51CTO