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
Javapublic class Geeks { public static void main(String[] args) { // Using lambda expression to implement Runnable new Thread(() -> System.out.println('New thread created')).start(); } }
Saída
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
Java@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); } }
Saída
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
Javaclass 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(); } }
Saída
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:
- Consumidor
- Predicado
- Função
- 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:
Fornecedor
fornecedor = () -> 'Olá mundo!';
Exemplo: Usando interface de predicado para filtrar strings
alterar nome do diretório linuxJava
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); } } }
Saída
Geek GeeksQuiz Geek2
Tabela de Interfaces Funcionais
Interfaces Funcionais | Descrição | Método |
---|---|---|
Executável | Representa uma tarefa que pode ser executada por um thread. | execução nula() |
Comparável | Ele compara dois objetos para ordenação. | int compararTo(T o) |
ActionListener | Ele lida com um evento de ação na programação orientada a eventos. | ação nulaPerformed(ActionEvent e) |
Chamável | Representa uma tarefa que pode retornar um resultado ou lançar uma exceção. | V call() lança exceção |
Consumidor | Aceita um único argumento de entrada e não retorna nenhum resultado. | anular aceitar (T t) |
Predicado | Aceita um único argumento e retorna um resultado booleano. | teste booleano (T t) |
Função | Aceita um único argumento e retorna um resultado. | R aplicar(T t) |
Fornecedor | Não requer nenhum argumento, mas fornece um resultado. o sorriso mais bonito | T get () |
Biconsumidor | Aceita dois argumentos e não retorna nenhum resultado. | nulo aceitar (T t U u) |
BiPredicado | Aceita dois argumentos e retorna um resultado booleano. | teste booleano (T t U u) |
BiFunção | Aceita dois argumentos e retorna um resultado. | R aplicar(T t U u) |
Operador Unário | Este é um caso especial de Function onde os tipos de entrada e saída são iguais. classificar arraylist em java | T se aplica(T t) |
Operador Binário | Este é um caso especial de BiFunction onde os tipos de entrada e saída são iguais. | T se aplica(T t1 T t2) |
Artigos relacionados
- Java 8
- Expressões Java Lambda