Une expression lambda avec une seule instruction (retournant void ​), bien qu'elle ne soit pas une expression, peut être utilisée sans les accolades, ex: () -> System.out.println("une instruction") ​;

Outre les paramètres d'expressions lambda, elles peuvent être utilisées pour :

• try-with-resource
• variables de boucles for ​
• paramètres d'exceptions

• Une fermeture est une fonction qui peut référencer des variables déclarées hors d'elle sans restrictions.
• Les expressions lambda de Java sont contraintes : elles ne peuvent pas modifier le contenu de variables locales (car n'ont donc accès qu'à des variables locales réellement final ​) : elles peuvent réaliser des fermetures sur des valeurs, et non sur des variables.
• Les variables d'instances sont elles accessibles via la capture de la variable locale final this ​.

• méthode d'instance sans paramètre
  • lambda :(Etudiant étudiant) -> étudiant.getID() ​
    • Etudiant::getID ​
• méthode d'instance avec paramètre
  • lambda : (étudiant, ue) -> étudiant.valideUE(ue) ​
    • Etudiant::valideUE ​
  • lambda : (ue) -> this.valideUE(ue) ​
    • this::valideUE ​

• références à des méthodes static ​
  • lambda : (arguments) -> Classe.méthodeStatique(arguments) ​
    • Classe::méthodeStatique ​
    • ex. : Math::cos ​
• références à des méthodes d'instance
  • lambda : (argument0, autresArguments) -> argument0.méthodeInstance(autresArguments) ​
    • Classe::méthodeInstance ​
    • ex. : Etudiant::getID ​
• références à des méthodes d'instance d'un objet existant ou d'une expression
  • lambda : (arguments) -> expression.méthodeInstance(arguments) ​
    • expression::méthodeInstance ​
    • ex. : élève::getID ​
• références à des constructeurs
  • lambda : (arguments) -> new Classe(arguments) ​
    • Classe::new ​
    • ex. : transmission d'un constructeur à une méthode ❶ qui instanciera de futurs objets de cette classe ❷. Le type du paramètre est une fonction qui prend en paramètre un entier et retourne un nouvel objet du type du constructeur : Function< Integer, SalleDeCours> ​ ❸

List< Integer> capacités = Arrays.asList(25, 25, 50);
List< SalleDeCours> salles = map(capacités, SalleDeCours::new); // ❶
List< SalleDeCours> map(List< Integer> capacités, Function<Integer, SalleDeCours> constructeur) { // ❸
	List< SalleDeCours> résultat = new ArrayList< >();
	for (Integer capacité : capacités) {
		résultat.add(constructeur.apply(capacité)); // ❷
	}
	return résultat;
}

• méthode qui retourne un Comparator ​ fondé sur une Function ​ qui utilise une valeur des objets pour leur comparaison :
  • Comparator<Etudiant> comparateur = Comparator.comparing(Etudiant::getAgeEnJours); ​
• inversion de l'ordre de tri par composition :
  • Comparator.comparing(Etudiant::getAgeEnJours).reversed() ​
• inversion de l'ordre de tri par composition :
  • Comparator.comparing(Etudiant::getAgeEnJours).reversed() ​
• composition d'un tri secondaire:
  • Comparator.comparing(Etudiant::getAgeEnJours).thenComparing(Etudiant::getID) ​

• méthodes de compositionnegate ​, and ​ et or ​

  Predicate< Etudiant> étudiantsIIM = (Elève élève) -> élève.getSpécialité().equals(Département.IIM);
  Predicate< Etudiant> étudiantsNonIIM = étudiantsIIM.negate();
  Predicate< Etudiant> étudiantsNonIIMAnglais = étudiantsNonIIM
  	.and(étudiant -> !étudiant.mobilitéOK())
  	.or(étudiant -> étudiant.scoreTOEIC < 500);
  

• méthode de compositioncompose ​ : calcule tout d'abord la fonction passée en paramètre (g(x) ​), puis la fonction utilisée (f(x) ​), soit f(g(x)) ​

  Function< Integer, Integer> f = x -> x + 1;
  Function< Integer, Integer> g = x -> x * 2;
  Function< Integer, Integer> h = f.compose(g);
  int résultat = h.apply(1); // f(g(1)) = f(2) = 3
  

• méthode de composition andThen ​ :calcule tout d'abord la fonction utilisée (f(x) ​), puis la fonction passée en paramètre (g(x) ​), soit g(f(x)) ​
  • permet de définir des suites (pipelines) d'applications de fonction, ex. :

  Function< String, String> corrigeTexte = TexteUtils::corrigeTexte;
  Function< String, String> transformations = 
  	corrigeText
  	.andThen(TexteUtils::simplifieTexte)
  	.andThen(TexteUtils::ajouteAnnotations);
  

• produisent un résultat (possiblement void ​, ex. forEach ​)
• ferment une stream
• opérations importantes :
  • collect ​ : réduit la stream pour obtenir une collection
  • count ​ : retourne le nombre d'éléments d'une stream (long ​)
  • forEach ​ : applique une expression lambda pour chaque élément d'une stream

• peuvent être connectées pour des traitements enchaînés
• aucun traitement tant qu'une opération terminale n'est pas appelé (traitement paresseux) : permet à une opération terminale de réduire des opérations intermédiaires en une seule passe
• opérations importantes :
  • filter ​ : filtre les éléments d'une stream à l'aide de Predicate<T> ​ (retourne boolean ​), retourne Stream<T> ​
  • limit ​ : conserve un certain nombre d'éléments, retourne Stream<T> ​
  • distinct ​ : consever les éléments uniques, retourne Stream<T> ​
  • map ​ : établit une correspondance avec les éléments d'une stream à l'aide de Function<T, R> ​ (retourne R ​), retourne Stream<R> ​
  • sorted ​ : tri les éléments d'une stream à l'aide de Comparator<T> ​ (retourne int ​), retourne Stream<T> ​

record Elève(String name, int toeicScore) { }  
  
List<Elève> élèves = Arrays.asList(  
        new Elève("E1", 500),  
        new Elève("E2", 700),  
        new Elève("E3", 200),  
        new Elève("E4", 600),  
        new Elève("E5", 100),  
        new Elève("E6", 800)  
);  
  
List< String> résultat = élèves.stream()  
        .filter( e -> e.toeicScore() >= 600  )  
        .map( e -> e.name + " " + e.toeicScore())  
        .limit(2)  
        .toList();  
  
résultat.stream().forEach(e -> System.out.println(e));

• On voudrait connaître tous les cours suivis par au moins un élève d'une classe
  - on suppose que la classe Elève ​ dispose d'une méthode List<Cours> getCoursSuivis() ​

Stream< List< Cours>> stream = élèves.stream() // Stream< Elève>
	.map(élève -> élève.getCoursSuivis()); // Stream< List< Cours>> 

stream.forEach(cours -> System.out.println(cours));

• On obtient une Stream<List<Elève>> ​, sur lequel on ne peut pas directement extraire la liste des cours suivis (sans répétition), ex.

[CS101, CS203, CS440, CS601]
[CS101, CS201, CS440, CS605]
[CS101, CS201, CS202, CS402, CS711]
...

• La méthode flatMap ​ remplace chaque valeur d'une stream, puis concatène les différentes streams en une seule (flattening) : on peut ici utiliser List::stream ​ pour obtenir une stream pour chaque List<Cours> ​

Stream< List< Cours>> stream = élèves.stream() // Stream< Elève>
	.map(élève -> élève.getCoursSuivis()) // Stream< List< Cours>> 
	.flatMap(List::stream) // Stream< Cours>
	.sorted() // on suppose que Cours est Comparable< Cours>
	.distinct();

stream.forEach(cours -> System.out.println(cours));

• On obtient cette fois une liste aplatie, puis triée et dédoublonnée, ex.

[CS101, CS201, CS202, CS203, CS402, CS440, CS601, CS605, CS711]

Optional< Integer> min = nombres.stream()
	.reduce( (e1, e2) -> e1 < e2 ? e1 : e2 );

ou avec une référence de méthode :

Optional< Integer> min = nombres.stream()
	.reduce(Integer::min);

• Surcharge retournant un Optional<T> ​ (si la stream est vide) :

Optional< Integer> somme = nombres.stream()
	.reduce( (e1, e2) -> e1 + e2 );

ou surcharge qui prend une valeur initiale :

Optional< Integer> somme = nombres.stream()
	.reduce(0, Integer::sum);

La méthode collect ​ est conçue pour modifier un accumulateur pour calculer son résultat, de façon compatible avec une traitement parallèle par les streams.

• en séquentiel :

long sommeEnSéquentiel(long n) {
	return Stream.iterate(1L, i -> i + 1)
		.limit(n)
		.reduce(0L, Long::sum);
}

• en parallèle ❶ :

long sommeEnParallèle(long n) {
	return Stream.iterate(1L, i -> i + 1)
		.limit(n)
		.parallel() // ❶
		.reduce(0L, Long::sum);
}

• Séparation (transparente) de la stream en plusieurs parties, réduction de chacune de ces parties en parallèle, puis même opération de réduction sur les résultats pour chaque partie

• par défaut, utilisation d'un nombre de threads correspondant aux nombre de cores disponibles :
  Runtime.getRuntime().availableProcessors() ​
• configuration par thread parallèle impossible, mais possibilité de configuration globale :
  System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "4"); ​

• La parallélisation est mal adaptée en cas d'accès partagé à des données mutables (accès concurrents)
• Sur de faibles volumes de données, les traitements parallèles induisent un coût qui ne sera souvent pas compensé
• Les streams pour des types primitifs (ex. IntStream ​) évitent de coûteux autoboxing / unboxing
• Certains opérations sont mal adaptées aux traitements parallèles : par exemple findFirst ​ qui repose sur l'ordre des éléments est coûteux, alors que findAny ​ le sera beaucoup moins

• Il est à la fois pertinent d'utiliser au mieux la capacité de traitement d'une machine en occupant autant que possible l'ensemble de ses processeurs
• Mais il faut anticiper des accès concurrents aux ressources de la machine hôte

Le patron Template porte sur des situations où l'on souhaite pouvoir adapter localement un algorithme. Cela peut typiquement être représenté au travers de méthodes abstraites, qui seront implémentées dans des sous-classes qui préciseront leur stratégie propres, ex.

abstract class École {
	public void inscrireÉlève(int id) {
		Élève e = getÉlève(id);
		inscrireÉlève(e);
	}
	abstract void inscrireÉlève(Élève e);
}

• Il est possible de transmettre à une méthode une/des expressions lambda qui viendront donc paramétrer son exécution, ex.

public void inscrireÉlève(int id, Consumer< Élève> inscrireÉlève) {
	Élève e = getÉlève(id);
	inscrireÉlève.accept(e);
}

• Ce qui permet de tels appels :

école.inscrireÉlève(237, 
					(Élève e) -> e.message("Merci " + e.getNom() + " de venir chercher le laisser-passer A38") );

Le patron Factory vise à masquer au client d'une classe ses détails d'instanciation, ex.

class DocumentFactory {
	public Document produireDocumentReglémentaire(String nomDocument) {
		return switch (name) {
			case "règlement intérieur" -> new DocumentRèglementIntérieur();
			case "charte web" -> new DocumentCharteWeb();
			default -> throw new IllegalArgumentException("Type de document inconnu : " + nomDocument);
		};
	}
}

• Il est possible d'utiliser des objets de type Supplier<T> ​ pour la création de chaque type de documents, qui peuvent donc être organisés dans des map, ex.

Map< String, Supplier< Document>> map = new HashMap<>(); 
map.put("règlement intérieur", DocumentRèglementIntérieur::new);
map.put("charte web", DocumentCharteWeb::new);
// …
class DocumentFactory {
	public Document produireDocumentReglémentaire(String nomDocument) {
		Supplier< Document> supplier = map.get(nomDocument);
		if (supplier != null) return supplier.get();
		throw new IllegalArgumentException("Type de document inconnu : " + nomDocument);
	}
}