6. Las interfaces funcionales de la biblioteca RxJava

La clase Observable constituye la base de la biblioteca asíncrona RxJava. Presenta muchas similitudes con la clase Stream que acabamos de presentar. Al igual que esta, cuenta con un gran número de métodos, varias decenas. Y, al igual que esta, dichos métodos admiten como parámetros instancias de interfaces funcionales. Comenzaremos por presentar las más comunes de ellas: [Actioni] y [Funci].

6.1. Ejemplo-01: la interfaz funcional [Action0]

La interfaz [Action0] es la siguiente:

La interfaz [Action0] tiene un único método, «call», con la firma [2]: void call(). Deriva de las interfaces [Action] y [1, 3]. La interfaz [Action] no tiene métodos. A este tipo de interfaces se las denomina interfaces marcadoras [4]. Sirven principalmente para escribir: if(c instanceOf(Action)) {...}. La interfaz [Action] deriva a su vez 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) {
    // Acción0
    Action0 a01 = new Action0() {
      @Override
      public void call() {
        System.out.println("anonymous a01.call");
      }
    };
    Action0 a02 = () -> System.out.println("lambda ao2.call");
    // visualizaciones
    a01.call();
    a02.call();
  }
}

líneas 8-13: implementación de la interfaz [Action0] con una clase anónima;
líneas 8-13: implementación de la interfaz [Action0] con un 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) {
    // Acción1
    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));

    // ejecuciones
    a10.call(20);
    a11.call(17.4);
  }
}

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 que tiene un único método de 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) {
    // Acción2
    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);
    // ejecuciones
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

El resultado obtenido 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) {
    // Función0
    Func0<String> f00 = new Func0<String>() {
      @Override
      public String call() {
        return "anonymous f00.call";
      }
    };
    Func0<String> f01 = () -> "lambda f01.call";
    // ejecuciones
    System.out.println(f00.call());
    System.out.println(f01.call());
  }
}

que da 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 que tiene un único método de firma: 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);
    // visualizaciones
    System.out.println(f20.call(10,10.2));
    System.out.println(f21.call(100, 100.3));
  }
}

que da los siguientes resultados:

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