Une expression lambda permet de définir un block de code qui peut être assigné à une référence d'une méthode.

Une expression lambda peut être utilisée dans plusieurs context:

• Initialiser une variable ou un tableau.
  
  
• Arguments de méthodes ou de constructeurs
  
  
• Valeur de retour de méthodes
  
  
• Expression conditionnelle "?:"
  
  

La syntaxe d'une expression lambda est comme suit: paramètres -> implémentation

Le caractère -> sépare les paramètres de l'implémentation de l'expression lambda.

• Les paramètres définissent les variables qui vont être utilisées comme argument lors de l'execution de l'expression lambda.
  
  Il n'est pas nécessaire de specifier le type des paramètres lorsque le compilateur peut inférer le type dépendamment du context d'utilisation de l'expression lambda.
  
  Le type peut être soit omis pour tous les paramètres, soit spécifié pour tous les paramètres. Une erreur de compilation est lancée si le type est spécifié pour certains paramètres, mais pas pour tous.
  
  Il est possible de définir une expression lambda qui n'accepte pas de paramètres.
  
  Les parenthèses () ne sont pas obligatoires lorsque l’expression lambda n’accepte qu’un seul paramètre.
  
  Exemples:
  
  • types explicites : (Integer i, Integer j) -> i + j;
    
  • types inférés : (i, j) -> i + j;
    
  • pas de paramètres : () -> Math.random();
    
  • pas de parenthèses : i -> i;
    
  
  
• L'implementation définit une expression ou un bloc d'instructions.
  
  Exemples:
  
  • expression : (String s) -> s.toUpercase();
    
  • bloc d'instructions : (String s) -> { return s.toUpercase(); }
    
  
  
• L’expression lambda peut retourner une valeur dont le type est inféré automatiquement par le compilateur.
  
  Exemples:
  
  • expression : () -> "hello!";
    
  • bloc d'instructions : () -> { return "hello!"; }
    
  • aucune valeur retournée : () -> System.out.println("Hello!");
    
  • une autre expression lambda: x -> y -> x + y;
    
  
  

L'implementation d'une expression lambda est similaire au code habituelle (bloc d'instructions) qu'on écrit pour implementer des méthodes. Cependant quelques restrictions sont à respecter, comme l'incapacité d'écrire des instructions continue/break à moins que ca soit à l'intérieur d'une boucle. Aussi il n'est pas possible de lancer des exceptions vérifiées par le compilateur (checked exceptions).
public class TestLambda { public Predicate<Integer> testCheckedException() { Predicate<Integer> predicate = t -> { if (t == 0) { throw new IllegalStateException("t should not be equal 0"); } // you can't throw a checked exception, the compiler will complain with the follwing erreor: // "Unhandled exception type Exception" // if (t % 2 == 0) { // throw new Exception("t should be odd"); // } return t >= 1; }; return predicate; } }
Le code d’une expression lambda peut référencer des variables locales ansi que des variables d’instances et des variables de classe (statique). Typiquement la variable local doit être déclarée avec le modificateur final mais ce n’est pas une nécessité tant que la variable est implicitement utilisée comme une variable finale.
public class TestLambda { private Integer instanceVar1; private static Integer classVar1; // A simple example to show how to access local variables, and instance and class fields. public Predicate<Integer> testVariablesAccess() { final Integer localVar1 = 0; Integer localVar2 = 0; Predicate<Integer> predicate = t -> { instanceVar1 = 0; classVar1 = 0; // The following code code will cause a compiler error: // "Local variable localVar2 defined in an enclosing scope must be final or effectively final" // localVar2 = 0; if (localVar1 == instanceVar1) { return true; } else if (localVar2 == classVar1) { return false; } else { return t % 2 == 0; } }; return predicate; } }
Les expressions lambda peuvent être assignées à des références des interfaces declarant une seule méthode.
Exemple :
Runnable runnable = () -> System.out.println("running ...");

• forEach
  L'interface java.lang.Iterable définit une implementation par défaut de la méthode forEach.
  public interface Iterable<T> { default void forEach(Consumer<? super T> action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); } } }
  La méthode forEach définit un paramètre de type Consumer (interface fonctionnelle) qui permet d'appliquer une action spécifique sur chaque élément d'une collection.
  
  L'interface java.util.Collection étend l'interface Iterable et donc la méthode forEach est disponible pour toute les implementations de l'interface Collection.
  
  Exemple:
  Collection<String> list = Arrays.asList("A", "B", "C"); list.forEach(new Consumer<String>() { public void accept(String t) { System.out.println(t); }; }); list.forEach((final String t) -> System.out.println(t)); list.forEach((String t) -> System.out.println(t)); list.forEach(t -> System.out.println(t)); list.forEach(System.out::println);