Introducción de Map, FlatMap, SwitchMap y ConcatMap

Muy buenas, soy Miguel y aquí les traigo otro nuevo artículo.

Todos estos operadores son elementos de transformación que son emitidos por un Observable. Aplican una función a los datos emitidos por un Observable.

Pero analicemos los escenarios de casos de uso que cumplen con sus requisitos.

Map

Map transforma los elementos emitidos por un Observable, aplicando una función a cada elemento.

Entendamos a través de un ejemplo:

Una secuencia observable emitirá valores enteros de rango de 1 a 5. Al usar el operador de mapa, transformaremos las series emitidas en una tabla de 10 e imprimiremos cada elemento emitido como un valor de cadena en nuestro código.

Observable.range(1,5)
.map(new Function<Integer, String>() 
@Override
public String apply(Integer number) throws Exception 
return "10 X " + number + " = " + (10 * number);
)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new DisposableObserver<String>() 
@Override
public void onNext(String output) 
System.out.println(output);

@Override
public void onError(Throwable e)
@Override
public void onComplete() 
);
output:
10 X 1 = 10
10 X 2 = 20
10 X 3 = 30
10 X 4 = 40
10 X 5 = 50

FlatMap

El operador FlatMap transforma un Observable aplicando una función que usted especifica a cada elemento emitido por el Observable de origen, donde esa función devuelve un Observable que a su vez emite elementos.

Entendamos a través de un ejemplo:

A través de la matriz del operador fromArray convertida en Observable Stream que emitirá caracteres A a F en secuencia. Al usar FlatMap, el operador «x» se agregará con cada elemento y, a través del operador, todos los elementos modificados se emiten como un solo elemento observable.

String strArray[] = {"A","B","C","D","E","F"};

Observable.fromArray(strArray)
        .flatMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(String s) throws Exception {
                final int delay = new Random().nextInt(10);
                return Observable.just(s + "x").delay(delay,         TimeUnit.SECONDS);
            }
        }).subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new DisposableObserver<String>() {

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
            }
        });Output:
Bx
Ax
Ex
Fx
Cx
Dx

Entonces, al operador de FlatMap no le importa el orden de los artículos. Crea un nuevo observable para cada elemento. Algunos de ellos emitirán más rápido y otros más lento porque retrasamos cada uno de ellos por una cantidad aleatoria de segundos.

A tener en cuenta: Con el operador FlatMap, el orden de los elementos emitidos no se mantiene, para este operador ConcatMap debe usar.

ConcatMap

ConcatMap mantiene el orden de los elementos y espera a que el Observable actual complete su trabajo antes de emitir el siguiente. ConcatMap es más adecuado cuando desea mantener el orden de ejecución.

Tomemos el mismo ejemplo que usamos en el caso de FlatMap, pero en el caso de ConcatMap, la salida del operador estará en secuencia.

String strArray[] = {"A","B","C","D","E","F"};

Observable.fromArray(strArray)
        .concatMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(String s) throws Exception {
                final int delay = new Random().nextInt(10);
                return Observable.just(s + "x").delay(delay,         TimeUnit.SECONDS);
            }
        }).subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new DisposableObserver<String>() {

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }
            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
            }
        });Output:
Ax
Bx
Cx
Dx
Ex
Fx

SwitchMap

SwitchMap es un operador completamente diferente de FlatMap y ConcatMap. Se cancelará la suscripción y dejará de reflejar el observable que se generó a partir del elemento emitido anteriormente, y comenzará a reflejar solo el actual. Es más adecuado cuando desea descartar la respuesta y considerar la última. Ejemplo en caso de extracción para actualizar y búsqueda instantánea, se enviarán varias solicitudes al servidor, pero es necesario mostrar el último resultado.

Tomemos el mismo ejemplo, pero en el caso de switchMap, la salida del operador estará en Fx porque se da de baja del observable anterior después de emitir uno nuevo.

String strArray[] = {"A","B","C","D","E","F"};

Observable.fromArray(strArray)
        .switchMap(new Function<String, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(String s) throws Exception {
                final int delay = new Random().nextInt(5);
                return Observable.just(s + "x").delay(delay, TimeUnit.SECONDS);
            }
        }).subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new DisposableObserver<String>() {

            @Override
            public void onNext(String s) {
                System.out.println(s);
            }

            @Override
            public void onError(Throwable e) {
            }
            @Override
            public void onComplete() {
            }
        });Output:
Fx

Mapa: Transforma los artículos, devuelve el artículo no observable.
FlatMap: No conserva el orden de los elementos, funciona de forma asincrónica
ConcatMap: Preservando el orden de los elementos, funciona sincrónicamente
SwitchMap: Darse de baja de un observable anterior después de emitir uno nuevo.

Gracias por leer este artículo.