Di recente ho imparato l'espressione Lambda che è stata introdotta in Java 8. Trovo che ogni volta che utilizzo un'interfaccia funzionale, tendo sempre a usare un'espressione Lambda invece di creare una classe che implementa l'interfaccia funzionale.

Questa è considerata una buona pratica? O le loro situazioni in cui l'uso di una Lambda per un'interfaccia funzionale non è appropriato?

Esistono diversi criteri che dovrebbero farti considerare di non utilizzare un lambda:

• Dimensione Più una lambda diventa grande, più diventa difficile seguire la logica che la circonda.
• Ripetizione È meglio creare una funzione con nome per la logica ripetuta, anche se va bene ripetere lambda molto semplici che si dividono.
• Denominazione Se riesci a pensare a un grande nome semantico, dovresti invece usarlo, poiché aggiunge molta chiarezza al tuo codice. Non sto parlando di nomi come priceIsOver100. x -> x.price > 100è chiaro come quel nome. Intendo nomi come isEligibleVoterquelli sostituiscono un lungo elenco di condizioni.
• Nidificazione I lambda nidificati sono davvero, davvero difficili da leggere.

Non esagerare. Ricorda, il software può essere facilmente modificato. In caso di dubbi, scrivilo in entrambi i modi e vedi quale è più facile da leggere.

Dipende. Ogni volta che ti ritrovi a utilizzare la stessa lambda in luoghi diversi, dovresti prendere in considerazione l'implementazione di una classe che implementa l'interfaccia. Ma se avessi usato una classe interna anonima, altrimenti penso che una lambda sia molto meglio.

Sostengo la risposta di Karl Bielefeldt, ma voglio fornire una breve aggiunta.

• Debug Alcuni IDE lottano con l'ambito all'interno di un lambda e fanno fatica a visualizzare le variabili membro all'interno del contesto di un lambda. Mentre speriamo che questa situazione cambierà in futuro, può essere fastidioso mantenere il codice di qualcun altro quando è disseminato di lambda.

Accesso alle variabili locali dell'ambito allegato

La risposta accettata da Karl Bielefeldt è corretta. Posso aggiungere un'altra distinzione:

• Scopo

Il codice lambda nidificato all'interno di un metodo all'interno di una classe può accedere a qualsiasi variabile efficacemente finale trovata all'interno di quel metodo e classe.

La creazione di una classe che implementa l'interfaccia funzionale non ti dà tale accesso diretto allo stato del codice chiamante.

Per citare il Tutorial Java (enfasi sul mio):

Come le classi locali e anonime, le espressioni lambda possono catturare variabili; hanno lo stesso accesso alle variabili locali dell'ambito allegato . Tuttavia, a differenza delle classi locali e anonime, le espressioni lambda non presentano alcun problema di ombreggiatura (vedere Ombreggiatura per ulteriori informazioni). Le espressioni lambda hanno un ambito lessicale. Ciò significa che non ereditano alcun nome da un supertipo né introducono un nuovo livello di ambito. Le dichiarazioni in un'espressione lambda vengono interpretate esattamente come nell'ambiente che la racchiude.

Quindi, mentre ci sono vantaggi nell'estrarre il codice lungo e nominarlo, è necessario valutarlo rispetto alla semplicità dell'accesso diretto allo stato del metodo e della classe inclusi.

Vedere:

• Accesso alle variabili locali di Enclosing Scope ( Java Tutorials by Oracle)
• Qual è il vantaggio di poter utilizzare in modo efficace le variabili finali nelle espressioni lambda di Java 8
• Differenza tra finale ed effettivamente finale

Questo potrebbe essere un pignolo, ma a tutti gli altri punti eccellenti fatti in altre risposte, aggiungerei:

Preferire i riferimenti ai metodi quando possibile. Confrontare:

employees.stream()
         .map(Employee::getName)
         .forEach(System.out::println);

contro

employees.stream()
         .map(employee -> employee.getName())
         .forEach(employeeName -> System.out.println(employeeName));

L'uso di un riferimento al metodo consente di risparmiare la necessità di nominare gli argomenti della lambda, che di solito sono ridondanti e / o portano a nomi pigri come eo x.

Basandosi sulla risposta di Matt McHenry, può esserci una relazione tra lambda e riferimenti al metodo in cui il lambda può essere riscritto come una serie di riferimenti al metodo. Per esempio:

employees.stream()
         .forEach(employeeName -> System.out.println(employee.getName()));

vs

employees.stream()
         .map(Employee::getName)
         .forEach(System.out::println);