6. Las interfaces funcionales de la biblioteca RxJava

La clase Observable constituye la base de la biblioteca asíncrona RxJava. Comparte muchas similitudes con la clase Stream que acabamos de ver. Al igual que Stream, ofrece un gran número de métodos: varias docenas. Y al igual que Stream, estos métodos aceptan instancias de interfaces funcionales como parámetros. Comenzaremos presentando las más comunes: [Action] y [Function].

6.1. Ejemplo-01: La interfaz funcional [Action]

La interfaz [Action0] es la siguiente:

La interfaz [Action0] tiene un único método, `call`, con la firma [2]: `void call()`. Deriva de la interfaz [Action] [1, 3]. La interfaz [Action] no tiene métodos. Este tipo de interfaz se denomina interfaz marcadora [4]. Se utilizan principalmente para escribir: if(c instanceOf(Action)) {...}. La propia interfaz [Action] deriva de la interfaz marcadora [Function] [4-6];

Ilustraremos la interfaz [Action0] con el siguiente código (Ejemplo01):


package dvp.rxjava.lamdbas;
 
import rx.functions.Action0;
 
public class Exemple01 {
  public static void main(String[] args) {
    // Action0
    Action0 a01 = new Action0() {
      @Override
      public void call() {
        System.out.println("anonymous a01.call");
      }
    };
    Action0 a02 = () -> System.out.println("lambda ao2.call");
    // displays
    a01.call();
    a02.call();
  }
}

líneas 8–13: implementación de la interfaz [Action0] utilizando una clase anónima;
líneas 8–13: implementación de la interfaz [Action0] utilizando una lambda;

Los resultados son los siguientes:

1 2	`anonymous a01.call lambda ao2.call`

6.2. Ejemplo-02, 03: la interfaz funcional [Actioni]

La interfaz [Action1] es la siguiente:

Lo ilustraremos con el siguiente código (Ejemplo 02):


package dvp.rxjava.lamdbas;
 
import rx.functions.Action1;
 
public class Exemple02 {
  public static void main(String[] args) {
    // Action1
    Action1<Integer> a10 = new Action1<Integer>() {
      @Override
      public void call(Integer integer) {
        System.out.printf("anonymous a10.call (%s)%n", integer);
      }
    };
    Action1<Double> a11 = (d -> System.out.printf("lambda a11.call (%s)%n", d));
 
    // executions
    a10.call(20);
    a11.call(17.4);
  }
}

lo que da el siguiente resultado:

1 2	`anonymous a10.call (20) lambda a11.call (17.4)`

En general, [Actioni] (0 <= i <= 9) es una interfaz funcional con un único método de la siguiente firma: void call(T1 t1, T2 t2, ..., Ti ti). A continuación se muestra un ejemplo para [Action2] (Ejemplo03):


package dvp.rxjava.lamdbas;
 
import rx.functions.Action2;
 
public class Exemple03 {
  public static void main(String[] args) {
    // Action2
    Action2<Integer, Double> a20 = new Action2<Integer, Double>() {
      @Override
      public void call(Integer integer, Double aDouble) {
        System.out.printf("anonymous a20.call(%s,%s)%n", integer, aDouble);
      }
    };
    Action2<Integer, Double> a21 = (i, d) -> System.out.printf("lambda a21.call(%s,%s)%n", i, d);
    // executions
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

El resultado es el siguiente:

anonymous a20.call(10,11.3)
lambda a21.call(5,5.6)

6.3. Ejemplo-04, 05: la interfaz funcional [Funci]

La interfaz [Func0] es la siguiente:

En este caso, el método [call] de la interfaz devuelve un resultado de tipo R.

Ilustraremos la interfaz con el siguiente código:


package dvp.rxjava.lamdbas;

import rx.functions.Func0;
 
public class Exemple04 {
  public static void main(String[] args) {
    // Function0
    Func0<String> f00 = new Func0<String>() {
      @Override
      public String call() {
        return "anonymous f00.call";
      }
    };
    Func0<String> f01 = () -> "lambda f01.call";
    // executions
    System.out.println(f00.call());
    System.out.println(f01.call());
  }
}

lo que produce los siguientes resultados:

1 2	`anonymous a20.call(10,11.3) lambda a21.call(5,5.6)`

En general, [Funci] (0<=i<=9) es una interfaz funcional con una única firma de método: R call(T1 t1, T2 t2, ..., Ti ti). A continuación se muestra un ejemplo para [Func2] (Ejemplo05):


package dvp.rxjava.lamdbas;
 
import rx.functions.Func2;
 
public class Exemple05 {
  public static void main(String[] args) {
    // Func2
    Func2<Integer, Double, String> f20 = new Func2<Integer, Double, String>() {
      @Override
      public String call(Integer integer, Double aDouble) {
        return String.format("anonymous f20.call(%s,%s)", integer, aDouble);
      }
    };
    Func2<Integer, Double, String> f21 = (i,d) -> String.format("anonymous f21.call(%s,%s)", i, d);
    // displays
    System.out.println(f20.call(10,10.2));
    System.out.println(f21.call(100, 100.3));
  }
}

lo que da los siguientes resultados:

1 2	`anonymous f20.call(10,10.2) anonymous f21.call(100,100.3)`