Un'interfaccia funzionale in Java è un'interfaccia che contiene solo un metodo astratto. Le interfacce funzionali possono avere più metodi predefiniti o statici ma solo un metodo astratto.

Da Java 8 in poi è possibile utilizzare espressioni lambda e riferimenti a metodi per rappresentare l'istanza di un'interfaccia funzionale.

Esempio: utilizzo di un'interfaccia funzionale con espressione 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 

Spiegazione:

• Il programma sopra mostra l'uso dell'espressione lambda con l'interfaccia funzionale Runnable.
• Runnable ha un metodo astratto run() quindi si qualifica come un'interfaccia funzionale.
• Lambda()-> System.out.println('Nuovo thread creato') definisce il metodo run().
• new Thread().start() avvia un nuovo thread che esegue il corpo lambda

Nota:

UN F l'interfaccia funzionale può anche estendere un'altra interfaccia funzionale.

@FunctionalInterface Annotazione

L'annotazione @FunctionalInterface viene utilizzata per garantire che l'interfaccia funzionale non possa avere più di un metodo astratto. Nel caso in cui siano presenti più metodi astratti, il compilatore contrassegna un messaggio "Annotazione @FunctionalInterface inaspettata". Tuttavia non è obbligatorio utilizzare questa annotazione.

Nota:

L'annotazione @FunctionalInterface è facoltativa ma è consigliabile utilizzarla. Aiuta a individuare l'errore nella fase iniziale assicurandosi che l'interfaccia abbia un solo metodo astratto.

Esempio: definizione di un'interfaccia funzionale con l'annotazione @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 

Spiegazione :

• Square è un'interfaccia funzionale con un unico metodo calcola(int x).
• Un'espressione lambda (int x) -> x * x viene utilizzata per implementare il metodo di calcolo.
• Lambda prende x come input e restituisce x * x.

Interfacce funzionali Java prima di Java 8

Prima di Java 8 dovevamo creare oggetti di classe interna anonimi o implementare queste interfacce. Di seguito è riportato un esempio di come è stata implementata l'interfaccia Runnable prima dell'introduzione delle espressioni lambda.

Esempio: Programma Java per dimostrare l'interfaccia funzionale

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 

Interfacce funzionali Java integrate

Da Java SE 1.8 in poi ci sono molte interfacce che vengono convertite in interfacce funzionali. Tutte queste interfacce sono annotate con @FunctionalInterface. Queste interfacce sono le seguenti:

• Eseguibile: Questa interfaccia contiene solo il file correre() metodo.
• Paragonabile: Questa interfaccia contiene solo il metodo compareTo().
• Ascoltatore di azioni: Questa interfaccia contiene solo il metodo actionPerformed().
• Chiamabile: Questa interfaccia contiene solo il metodo call().

Tipi di interfacce funzionali in Java

Java SE 8 includeva quattro tipi principali di interfacce funzionali che possono essere applicate in molteplici situazioni, come indicato di seguito:

1. Consumatore
2. Predicato
3. Funzione 
4. Fornitore

1. Consumatore 

IL interfaccia del consumatore dell'interfaccia funzionale è quella che accetta solo un argomento o un argomento gentrificato. L'interfaccia del consumatore non ha alcun valore di ritorno. Non restituisce nulla. Esistono anche varianti funzionali del Consumer DoppioConsumatore IntConsumatore E LongConsumer . Queste varianti accettano valori primitivi come argomenti. 

Oltre a queste varianti esiste anche un'altra variante dell'interfaccia Consumer nota come Bi-consumo . 

Sintassi:

Consumatore consumatore = (valore) -> System.out.println(valore);

Questa implementazione dell'interfaccia funzionale Java Consumer stampa il valore passato come parametro all'istruzione print. Questa implementazione utilizza la funzione Lambda di Java.

2. Predicato 

IL Interfaccia del predicato rappresenta una funzione con valore booleano di un argomento. Viene comunemente utilizzato per filtrare le operazioni nei flussi. Proprio come l'interfaccia funzionale del consumatore, anche l'interfaccia funzionale del predicato ha alcune estensioni. Questi sono IntPredicate Doppio predicato E Predicato lungo . Questi tipi di interfacce funzionali predicate accettano solo tipi di dati o valori primitivi come argomenti.  

Sintassi: 

interfaccia pubblica Predicato{
   test booleano(T t);
}

L'interfaccia funzionale del predicato Java può essere implementata anche utilizzando espressioni Lambda.

Predicato predicato = (valore) -> valore != null;

test e tipi di software

3. Funzione

UN funzione è un tipo di interfaccia funzionale in Java che riceve solo un singolo argomento e restituisce un valore dopo l'elaborazione richiesta. Molte versioni diverse delle interfacce delle funzioni sono strumentali e vengono comunemente utilizzate nei tipi primitivi come double int long.

Sintassi:

Funzione funzione = (valore) -> valore * valore;

• Bifunzione: IL Bifunzione è sostanzialmente correlato ad una Funzione. Inoltre richiede due argomenti mentre Funzione accetta un argomento. 
• Operatore unario e operatore binario: Ci sono anche altre due interfacce funzionali denominate come Operatore unario E Operatore binario. Entrambi estendono rispettivamente la funzione e la bifunzione dove sia il tipo di ingresso che il tipo di uscita sono gli stessi.

4. Fornitore

IL Fornitore l'interfaccia funzionale è anche un tipo di interfaccia funzionale che non accetta alcun input o argomento e tuttavia restituisce un singolo output. Le diverse estensioni dell'interfaccia funzionale Fornitore contengono molte altre funzioni dei fornitori come BooleanSupplier DoubleSupplier LongSupplier E IntSupplier . Il tipo restituito di tutte queste ulteriori specializzazioni sono solo le primitive corrispondenti. 

Sintassi:

Fornitorefornitore = () -> 'Ciao Mondo!';

Esempio: Utilizzo dell'interfaccia del predicato per filtrare le stringhe

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 

Tabella delle interfacce funzionali

Articoli correlati

• Giava8
• Espressioni Lambda Java