RxJava Operator Series 2 (Part 1)

[[180035]]

RxJava operator source code portal

• https://github.com/xiehui999/fuseProgram

In the previous article, RxJava Operator Series 1, we introduced operators that create observers. Today's article will introduce the frequently used conversion operators.

Map

This operator applies a function to each item emitted by the original Observable and returns an Observable that emits those results.

For example, if we have an integer array of data, when it is greater than 5, the output is true, then the code implementation

 Integer [] integers = {0, 9, 6, 4, 8};
        Observable. from (integers).map(new Func1() {
 @Override
 public Boolean call( Integer   integer ) {
                Log.e(TAG, "call: " + integer );
 return ( integer > 5 );
 }
        }).subscribe(new Subscriber() {
 @Override
 public void onCompleted() {
                Log.e(TAG, "onCompleted: " );
 } 
  
 @Override
 public void onError(Throwable e) {
                Log.e(TAG, "onError: " );
 } 
  
 @Override
 public void onNext(Boolean aBoolean) {
                Log.e(TAG, "onNext: " +aBoolean);
 }
 });

Log output information

 call: 0
 onNext: false  
 call: 9
 onNext: true  
 call: 6
 onNext: true  
 call: 4
 onNext: false  
 call: 8
 onNext: true  
 onCompleted:

For map, it can transform the data source into the type you want. For example, if you want to get a Student object (with age and name attributes), we can get only the name through map. Next, let's take another example. We get an image according to an image path and set the image to ImageView, and then add ImageView to our layout.

 String path = Environment.getExternalStorageDirectory()+ File.separator+ "aaa.jpg" ;
 Observable.just(path)
                .subscribeOn(Schedulers.io())
                .map(new Func1() {
 @Override
 public Bitmap call(String s) {
                        Bitmap bitmap = BitmapFactory.decodeFile(s);
                        Log.e(TAG, "call: Bitmap" +bitmap);
 return bitmap;
 }
                }).map(new Func1() {
 @Override
 public ImageView call(Bitmap bitmap) {
                Log.e(TAG, "call: ImageView" );
                ImageView imageView = new ImageView(getActivity());
                LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(LinearLayout.LayoutParams.WRAP_CONTENT, LinearLayout.LayoutParams.WRAP_CONTENT);
                imageView.setLayoutParams(params);
                imageView.setImageBitmap(bitmap);
 return imageView;
 }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
 @Override
 public void onCompleted() {
                        Log.e(TAG, "onCompleted: " );
 }
 @Override
 public void onError(Throwable e) {
                        Log.e(TAG, "onError: " );
 } 
  
 @Override
 public void onNext(ImageView imageView) {
                        Log.e(TAG, "onNext: " );
                        layout.addView(imageView);
 }
 });

Cast

This operator is used to perform some forced type conversion operations. For example, when we jump to a page, the data object is often serialized. When we receive the data on the new page, we must force it to be converted to the type we want. The cast operator can also achieve this function. As follows

 Observable.just( serializable ) .cast (FileInfo.class).subscribe(new Subscriber() {
 @Override
 public void onCompleted() {
                Log.e(TAG, "onCompleted: " );
 } 
  
 @Override
 public void onError(Throwable e) {
                Log.e(TAG, "onError: " );
 } 
  
 @Override
 public void onNext(FileInfo fileInfo) {
                Log.e(TAG, "onNext: " +fileInfo.toString());
                tv1.append( "\n" +fileInfo.toString());
 }
 });

However, the actual use of this operator is not so widespread and is rarely used. Of course, this operator can also achieve the same role as instanceof in Java, which is used for type checking. When it is not of that type, the onError() method will be executed.

FlatMap

The difference between this operator and the map operator is that it transforms an Observable that emits data into multiple Observables, and then merges the data they emit into a single Observable.

 Integer [] integers = {1, 2, 3};
        Observable. from (integers).flatMap(new Func1>() {
 @Override
 public Observable call(final Integer   integer ) {
 return Observable.create (new Observable.OnSubscribe () {
 @Override
 public void call(Subscriber super String> subscriber) {
                        Log.e(TAG, "call: FlatMap " + Thread.currentThread().getName());
 try {
                            Thread.sleep(200);
                            subscriber.onNext( integer + 100 + " FlatMap" );
                            subscriber.onCompleted();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            subscriber.onError(e);
 }
 }
                }).subscribeOn(Schedulers.newThread());
 }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
 @Override
 public void onCompleted() {
                        Log.e(TAG, "onCompleted: FlatMap" );
 } 
  
 @Override
 public void onError(Throwable e) {
                        Log.e(TAG, "onError: FlatMap" );
 } 
  
 @Override
 public void onNext(String s) {
                        Log.e(TAG, "onNext: FlatMap " + s);
 }
 });

Print log information

 call: FlatMap RxNewThreadScheduler-2
 call: FlatMap RxNewThreadScheduler-3
 call: FlatMap RxNewThreadScheduler-4
 onNext: FlatMap 101 FlatMap
 onNext: FlatMap 102 FlatMap
 onNext: FlatMap 103 FlatMap
 onCompleted: FlatMap

ConcatMap

This operator is similar to the simplest version of flatMap, but it concatenates the resulting Observables in order instead of merging them, and then produces its own sequence of data. Change the above flatMap code to the following

 Integer [] integers = {1, 2, 3};
        Observable. from (integers).concatMap(new Func1>() {
 @Override
 public Observable call(final Integer   integer ) {
 return Observable.create (new Observable.OnSubscribe () {
 @Override
 public void call(Subscriber super String> subscriber) {
                        Log.e(TAG, "call:2 ConcatMap " + Thread.currentThread().getName());
 try {
                            Thread.sleep(200);
                            subscriber.onNext( integer + 100 + " ConcatMap" );
                            subscriber.onCompleted();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                            subscriber.onError(e);
 }
 }
                }).subscribeOn(Schedulers.newThread());
 }
        }).observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
 @Override
 public void onCompleted() {
                        Log.e(TAG, "onCompleted: ConcatMap" );
 } 
  
 @Override
 public void onError(Throwable e) {
                        Log.e(TAG, "onError: ConcatMap" );
 } 
  
 @Override
 public void onNext(String s) {
                        Log.e(TAG, "onNext: ConcatMap " +s);
 }
 });

Continue