6. As interfaces funcionais da biblioteca RxJava

A classe Observable constitui a base da biblioteca assíncrona RxJava. Ela apresenta muitas semelhanças com a classe Stream que acabamos de apresentar. Assim como ela, possui um grande número de métodos, várias dezenas. E, assim como ela, esses métodos aceitam como parâmetros instâncias de interfaces funcionais. Começaremos apresentando as mais comuns delas: [Actioni] e [Funci].

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 das interfaces [Action] e [1, 3]. A interface [Action] não possui métodos. Esse tipo de interface é chamado de interface marcadora [4]. Elas servem principalmente para escrever: if(c instanceOf(Action)) {...}. A interface [Action], por sua vez, deriva da interface marcadora [Function] [4-6];

Ilustraremos a interface [Action0] com o código a seguir (Exemplo01):


package dvp.rxjava.lamdbas;

import rx.functions.Action0;

public class Exemple01 {
  public static void main(String[] args) {
    // Ação 0
    Action0 a01 = new Action0() {
      @Override
      public void call() {
        System.out.println("anonymous a01.call");
      }
    };
    Action0 a02 = () -> System.out.println("lambda ao2.call");
    // visualizações
    a01.call();
    a02.call();
  }
}

linhas 8-13: implementação da interface [Action0] com uma classe anônima;
linhas 8-13: implementação da interface [Action0] com 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:

Ilustraremos isso com o código a seguir (Exemplo 02):


package dvp.rxjava.lamdbas;

import rx.functions.Action1;

public class Exemple02 {
  public static void main(String[] args) {
    // Ação1
    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));

    // execuções
    a10.call(20);
    a11.call(17.4);
  }
}

que produz o seguinte resultado:

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

De maneira geral, [Actioni] (0 <= i <= 9) é uma interface funcional com um único método de 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) {
    // Ação 2
    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);
    // execuções
    a20.call(10,11.3);
    a21.call(5,5.6);
  }
}

O resultado obtido é 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 retorna um resultado do tipo R.

Ilustraremos a interface com o código a seguir:


package dvp.rxjava.lamdbas;

import rx.functions.Func0;

public class Exemple04 {
  public static void main(String[] args) {
    // Função0
    Func0<String> f00 = new Func0<String>() {
      @Override
      public String call() {
        return "anonymous f00.call";
      }
    };
    Func0<String> f01 = () -> "lambda f01.call";
    // execuções
    System.out.println(f00.call());
    System.out.println(f01.call());
  }
}

que produz os seguintes resultados:

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

De modo geral, [Funci] (0 <= i <= 9) é uma interface funcional com um único método de assinatura: 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);
    // exibições
    System.out.println(f20.call(10,10.2));
    System.out.println(f21.call(100, 100.3));
  }
}

que produz os seguintes resultados:

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