J'ai récemment maîtrisé l'expression Lambda introduite dans java 8. Je constate que chaque fois que j'utilise une interface fonctionnelle, j'ai tendance à toujours utiliser une expression Lambda au lieu de créer une classe qui implémente l'interface fonctionnelle.

Est-ce considéré comme une bonne pratique? Ou sont leurs situations où l'utilisation d'un Lambda pour une interface fonctionnelle n'est pas appropriée?

Un certain nombre de critères devraient vous inciter à ne pas utiliser de lambda:

• Taille Plus un lambda est grand, plus il est difficile de suivre la logique qui l’entoure.
• Répétition Il est préférable de créer une fonction nommée pour la logique répétée, bien qu'il soit correct de répéter des lambdas très simples qui sont dispersés.
• Nommage Si vous pouvez penser à un bon nom sémantique, vous devriez l'utiliser à la place, car cela ajoute beaucoup de clarté à votre code. Je ne parle pas de noms comme priceIsOver100. x -> x.price > 100est tout aussi clair que ce nom. Je veux dire que des noms comme isEligibleVotercelui-ci remplacent une longue liste de conditions.
• Nidification Les lambdas nichés sont vraiment très difficiles à lire.

Ne va pas trop loin. Rappelez-vous, le logiciel est facilement modifié. En cas de doute, écrivez-le dans les deux sens et voyez ce qui est le plus facile à lire.

Ça dépend. Lorsque vous utilisez le même lambda à différents endroits, vous devriez envisager de mettre en œuvre une classe qui implémente l'interface. Mais si vous aviez utilisé une classe interne anonyme, je pense qu'un lambda est bien meilleur.

Je soutiens la réponse de Karl Bielefeldt, mais je souhaite ajouter un bref ajout.

• Débogage Certains IDE luttent avec la portée à l'intérieur d'un lambda et ont du mal à afficher les variables de membre dans le contexte d'un lambda. Bien que nous espérons que cette situation changera en bout de ligne, il peut être agaçant de conserver le code de quelqu'un d'autre lorsqu'il est jonché de lambdas.

Accès aux variables locales de la portée englobante

La réponse acceptée par Karl Bielefeldt est correcte. Je peux ajouter une distinction supplémentaire:

• Portée

Le code lambda imbriqué dans une méthode dans une classe peut accéder à toutes les variables finales trouvées dans cette méthode et cette classe.

Créer une classe qui implémente l'interface fonctionnelle ne vous donne pas un tel accès direct à l'état du code appelant.

Pour citer le tutoriel Java (l'emphase mienne):

Comme les classes locales et anonymes, les expressions lambda peuvent capturer des variables; ils ont le même accès aux variables locales de la portée englobante . Cependant, contrairement aux classes locales et anonymes, les expressions lambda ne présentent pas de problème d'observation (reportez-vous à la section Observation pour plus d'informations). Les expressions lambda ont une portée lexicale. Cela signifie qu'ils n'héritent d'aucun nom d'un supertype ni n'introduisent un nouveau niveau de périmètre. Les déclarations dans une expression lambda sont interprétées exactement comme dans l'environnement englobant.

Ainsi, s'il est avantageux d'extraire un code long et de le nommer, vous devez le comparer à la simplicité de l'accès direct à l'état de la méthode et de la classe englobantes.

Voir:

• Accès aux variables locales du domaine d'application ( didacticiels Java d'Oracle)
• Quel est l'avantage de pouvoir utiliser efficacement les variables finales dans les expressions Java 8 lambda
• Différence entre final et effectivement final

C'est peut-être une énigme, mais à tous les autres excellents points soulevés dans d'autres réponses, j'ajouterais:

Préférez les références de méthode lorsque cela est possible. Comparer:

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

contre

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

L'utilisation d'une référence de méthode vous évite d'avoir à nommer le ou les arguments de lambda, qui sont généralement redondants et / ou conduisent à des noms paresseux tels que eou x.

En se basant sur la réponse de Matt McHenry, il peut exister une relation entre lambda et les références de méthode, le lambda pouvant être réécrit sous la forme d'une série de références de méthodes. Par exemple:

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

contre

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