6. As interfaces funcionais da biblioteca RxJava

A classe Observable constitui a base da biblioteca assíncrona RxJava. Partilha muitas semelhanças com a classe Stream que acabámos de discutir. Tal como a Stream, oferece um grande número de métodos — várias dezenas. E, tal como a Stream, estes métodos aceitam instâncias de interfaces funcionais como parâmetros. Começaremos por apresentar as mais comuns: [Action] e [Function].

6.1. Exemplo-01: A interface funcional [Action0]

A interface [Action0] é a seguinte:

A interface [Action0] possui um único método, `call`, com a assinatura [2]: `void call()`. Ela deriva da interface [Action] [1, 3]. A interface [Action] não possui métodos. Este tipo de interface é designado por interface marcadora [4]. São utilizadas principalmente para escrever: if(c instanceOf(Action)) {...}. A própria interface [Action] deriva da interface marcadora [Function] [4-6];

Iremos ilustrar a interface [Action0] com o seguinte código (Exemplo01):


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();
  }
}

linhas 8–13: implementação da interface [Action0] utilizando uma classe anónima;
linhas 8–13: implementação da interface [Action0] utilizando um lambda;

Os resultados são os seguintes:

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

6.2. Exemplo-02, 03: a interface funcional [Actioni]

A interface [Action1] é a seguinte:

Iremos ilustrar isto com o código seguinte (Exemplo 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);
  }
}

o que dá o seguinte resultado:

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

Em geral, [Actioni] (0 <= i <= 9) é uma interface funcional com um único método com a seguinte assinatura: void call(T1 t1, T2 t2, ..., Ti ti). Aqui está um exemplo para [Action2] (Exemplo03):


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);
  }
}

O resultado é o seguinte:

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

6.3. Exemplo-04, 05: a interface funcional [Funci]

A interface [Func0] é a seguinte:

Desta vez, o método [call] da interface devolve um resultado do tipo R.

Vamos ilustrar a interface com o seguinte 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());
  }
}

o que produz os seguintes resultados:

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

Em geral, [Funci] (0<=i<=9) é uma interface funcional com uma única assinatura de método: R call(T1 t1, T2 t2, ..., Ti ti). Aqui está um exemplo para [Func2] (Exemplo05):


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));
  }
}

o que dá os seguintes resultados:

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