Uma interface funcional em Java é uma interface que contém apenas um método abstrato. As interfaces funcionais podem ter vários métodos padrão ou estáticos, mas apenas um método abstrato.

A partir do Java 8, expressões lambda e referências de método podem ser usadas para representar a instância de uma interface funcional.

Exemplo: usando uma interface funcional com expressão Lambda

public class Geeks {    public static void main(String[] args) {    // Using lambda expression to implement Runnable  new Thread(() -> System.out.println('New thread created')).start();  } } 

New thread created 

Explicação:

• O programa acima demonstra o uso da expressão lambda com a interface funcional Runnable.
• Runnable possui um método abstrato run() portanto, é qualificado como uma interface funcional.
• Lambda()-> System.out.println('Novo thread criado') define o método run().
• new Thread().start() inicia um novo thread que executa o corpo lambda

Observação:

UM f interface funcional também pode estender outra interface funcional.

@FunctionalInterface Anotação

A anotação @FunctionalInterface é usada para garantir que a interface funcional não pode ter mais de um método abstrato. Caso mais de um método abstrato esteja presente, o compilador sinaliza uma mensagem 'Anotação @FunctionalInterface inesperada'. No entanto, não é obrigatório usar esta anotação.

Observação:

A anotação @FunctionalInterface é opcional, mas é uma boa prática de usar. Isso ajuda a detectar o erro no estágio inicial, garantindo que a interface tenha apenas um método abstrato.

Exemplo: Definindo uma Interface Funcional com a Anotação @FunctionalInterface

@FunctionalInterface interface Square {  int calculate(int x); } class Geeks {  public static void main(String args[]) {  int a = 5;  // lambda expression to define the calculate method  Square s = (int x) -> x * x;  // parameter passed and return type must be same as defined in the prototype  int ans = s.calculate(a);  System.out.println(ans);  } } 

25 

Explicação :

• Square é uma interface funcional com um único método calcular (int x).
• Uma expressão lambda (int x) -> x * x é usada para implementar o método de cálculo.
• Lambda recebe x como entrada e retorna x * x.

Interfaces funcionais Java antes do Java 8

Antes do Java 8, tínhamos que criar objetos de classe interna anônimos ou implementar essas interfaces. Abaixo está um exemplo de como a interface Runnable foi implementada antes da introdução das expressões lambda.

Exemplo: Programa Java para demonstrar interface funcional

class Geeks {  public static void main(String args[]) {    // create anonymous inner class object  new Thread(new Runnable() {  @Override public void run()  {  System.out.println('New thread created');  }  }).start();  } } 

New thread created 

Interfaces funcionais Java integradas

Desde o Java SE 1.8 em diante, existem muitas interfaces que são convertidas em interfaces funcionais. Todas essas interfaces são anotadas com @FunctionalInterface. Essas interfaces são as seguintes:

• Executável: Esta interface contém apenas o correr() método.
• Comparável: Esta interface contém apenas o método compareTo().
• Ouvinte de ação: Esta interface contém apenas o método actionPerformed().
• Chamável: Esta interface contém apenas o método call().

Tipos de interfaces funcionais em Java

O Java SE 8 incluiu quatro tipos principais de interfaces funcionais que podem ser aplicadas em diversas situações, conforme mencionado abaixo:

1. Consumidor
2. Predicado
3. Função 
4. Fornecedor

1. Consumidor 

O interface do consumidor da interface funcional é aquela que aceita apenas um argumento ou um argumento gentrificado. A interface do consumidor não tem valor de retorno. Não retorna nada. Existem também variantes funcionais do Consumer Consumidor Duplo Consumidor Interno e LongConsumidor . Estas variantes aceitam valores primitivos como argumentos. 

como saber o tamanho da tela

Além dessas variantes, há também mais uma variante da interface do consumidor conhecida como Biconsumidor . 

Sintaxe:

Consumidor consumidor = (valor) -> System.out.println(valor);

Esta implementação da interface funcional Java Consumer imprime o valor passado como parâmetro para a instrução print. Esta implementação usa a função Lambda de Java.

2. Predicado 

O Interface predicada representa uma função com valor booleano de um argumento. É comumente usado para operações de filtragem em fluxos. Assim como a interface funcional do consumidor, a interface funcional predicada também possui algumas extensões. Estes são IntPredicado Predicado Duplo e LongPredicado . Esses tipos de interfaces funcionais predicadas aceitam apenas tipos de dados ou valores primitivos como argumentos.  

Sintaxe: 

Predicado de interface pública{
   teste booleano(T t);
}

A interface funcional de predicado Java também pode ser implementada usando expressões Lambda.

Predicado predicado = (valor) -> valor! = nulo;

tipos de árvores binárias

3. Função

UM função é um tipo de interface funcional em Java que recebe apenas um único argumento e retorna um valor após o processamento necessário. Muitas versões diferentes das interfaces de função são instrumentais e comumente usadas em tipos primitivos como double int long.

Sintaxe:

Função função = (valor) -> valor * valor;

• Bi-Função: O Bifuncional está substancialmente relacionado a uma Função. Além disso, são necessários dois argumentos, enquanto Function aceita um argumento. 
• Operador Unário e Operador Binário: Existem também duas outras interfaces funcionais que são nomeadas como Operador Unário e Operador Binário. Ambos estendem a função e a bifunção, respectivamente, onde o tipo de entrada e o tipo de saída são iguais.

4. Fornecedor

O Fornecedor interface funcional também é um tipo de interface funcional que não aceita nenhuma entrada ou argumento e ainda retorna uma única saída. As diferentes extensões da interface funcional do Fornecedor contêm muitas outras funções do fornecedor, como Fornecedor booleano Fornecedor Duplo Fornecedor Longo e Fornecedor Interno . O tipo de retorno de todas essas especializações adicionais são apenas as primitivas correspondentes. 

Sintaxe:

Fornecedorfornecedor = () -> 'Olá mundo!';

Exemplo: Usando interface de predicado para filtrar strings

alterar nome do diretório linux

import java.util.*; import java.util.function.Predicate; class Geeks {  public static void main(String args[]) {    // create a list of strings  List<String> n = Arrays.asList('Geek' 'GeeksQuiz' 'g1' 'QA' 'Geek2');  // declare the predicate type as string and use lambda expression to create object  Predicate<String> p = (s) -> s.startsWith('G');  // Iterate through the list  for (String st : n) {    // call the test method  if (p.test(st))  System.out.println(st);  }  } } 

Geek GeeksQuiz Geek2 

Tabela de Interfaces Funcionais

Artigos relacionados

• Java 8
• Expressões Java Lambda