Introdução a Interfaces Funcionais

O java 8 introduziu várias funcionalidades interessantes, como novas APIs de Stream, Optional, Date and Time e Functional Interfaces.

Este artigo tem o objetivo de fazer uma breve introdução sobre as Interfaces Funcionais e apresentar os tipos mais comuns disponíveis a partir do JDK 8.

Interfaces funcionais permitem trabalharmos com closures no Java. Closure é uma função que conhece o escopo na qual foi criada. Ou seja, a função tem acesso às suas variáveis e às variáveis e parâmetros da função externa que a criou. Com as interfaces funcionais, também é possível passarmos funções por parâmetros ou retorná-las.

Uma Interface Funcional deve obrigatoriamente possuir um e apenas um método abstrato, mas que pode ter outros métodos default.

Além disso, recomenda-se anotar a interface com @FunctionalInterface. Esta anotação irá ajudar o compilador a sinalizar um erro caso você tente adicionar mais de um método abstrato. Incluir essa anotação é opcional, desde que respeite a regra de ter apenas um método abstrato.

Exemplo:

@FunctionalInterface public interface Operacao { int calcular(int a, int b); } 

Para definir uma função a partir de uma interface, usamos expressões lambda. Lambda nada mais é do que uma função anônima, que não possui nome e nem está vinculada como um método de classe. Abaixo algumas diferentes formas de criar uma função usando expressão lambda:

1. Com as chaves: quando o corpo da função tiver várias instruções.

Funcao fn = (a, b) -> { System.out.println("Realizando a soma..."); // instrução 1 return a + b; // instrução 2 }; 

1. Sem as chaves: quando a função tiver apenas uma instrução. O resultado da instrução a + b será retornado na chamada da função.

Funcao fn = (a, b) -> a + b; 

1. Sem os parênteses do argumento: quando há apenas 1 parâmetro na função, podemos omitir os parênteses.

Funcao fn = x -> x * 2; 

Assim, utilizando o exemplo acima da interface Operacao, criamos várias operações matemáticas utilizando lambdas:

Operacao soma = (a, b) -> a + b; Operacao subtracao = (a, b) -> a - b; Operacao divisao = (a, b) -> a / b; Operacao multiplicacao = (a, b) -> a * b; System.out.println(soma.calcular(1, 2)); // 3 System.out.println(subtracao.calcular(5, 1)); // 4 System.out.println(divisao.calcular(10, 5)); // 2 System.out.println(multiplicacao.calcular(2, 5)); // 10 

Analisando o exemplo acima, podemos notar que a mesma interface foi utilizada para várias operações matemáticas e o código ficou bem reduzido e mais legível!

Mas se você não quer ficar criando interfaces funcionais no seu projeto, também pode utilizar das já disponiveis no próprio Java. Vamos conhecer algumas?

java.util.function.Function<T, R>

Esta função recebe um parâmetro do tipo T e retorna um valor do tipo R.

@FunctionalInterface public interface Function<T, R> { /** * Applies this function to the given argument. * * @param t the function argument * @return the function result */ R apply(T t); } 

Exemplo:

Function<Integer, Float> dividePorDois = x -> ((float) x / 2); System.out.println(dividePorDois.apply(15)); // 7.5 

java.util.function.Consumer<T>

Esta função recebe um parâmetro do tipo T, mas não retorna nada.

@FunctionalInterface public interface Consumer<T> { /** * Performs this operation on the given argument. * * @param t the input argument */ void accept(T t); } 

Exemplo:

Consumer<String> exibeMensagem = str -> System.out.println(str); // ou Consumer<String> exibeMensagem2 = System.out::println; exibeMensagem.accept("Hello World!"); // Hello World! exibeMensagem2.accept("Hello World!"); // Hello World! 

Note que, como o método println possui a mesma assinatura de método da interface Consumer<String> (recebe uma String e não retorna nada) e há somente uma instrução na função, podemos passar a referência do próprio método println. Isso se chama Method Reference.

java.util.function.Supplier<T>

Esta função não recebe parâmetros e retorna um valor do tipo T.

@FunctionalInterface public interface Supplier<T> { /** * Gets a result. * * @return a result */ T get(); } 

Exemplo:

Supplier<LocalDate> dataAtual = () -> LocalDate.now(); System.out.println(dataAtual.get()); // 2021-06-02 

java.util.function.Predicate<T>

Esta função recebe um parâmetro do tipo T e retorna um valor booleano.

@FunctionalInterface public interface Predicate<T> { /** * Evaluates this predicate on the given argument. * * @param t the input argument * @return {@code true} if the input argument matches the predicate, * otherwise {@code false} */ boolean test(T t); } 

Exemplo:

Predicate<LocalDate> maiorDeIdade = dataNascimento -> { return dataNascimento.until(LocalDate.now(), ChronoUnit.YEARS) >= 18; }; System.out.println(maiorDeIdade.test(LocalDate.of(1985, 10, 5))); // true 

As interfaces disponíveis no JDK abordadas neste artigo possuem especializações que permitem receber dois parâmetros (adicionando o prefixo Bi) ou trabalhar diretamente com tipos primitivos (adicionando o prefixo Int, Long ou Double). Exemplos: BiFunction, IntFunction, LongFunction e DoubleFunction.

Vimos os quatro principais tipos de interfaces funcionais. Recomendo que você explore as diversas opções que a JDK fornece e aplicá-las sempre que possível nos projetos.

Os exemplos utilizados neste artigo estão no repositório: https://github.com/andrebuarque/functional-interfaces-java.

Até logo!