Leçons

Pratique des expressions lambda dans les collections et Stream API : comment remplacer les classes anonymes par des lambdas compactes, utiliser les méthodes des collections ( forEach, removeIf, sort, replaceAll) et construire des pipelines de traitement des données ( stream → filter → map → sorted → collect). Nous comparerons avec les classes anonymes, discuterons des variables « effectivement final », proposerons un tableau des opérations principales et analyserons les erreurs typiques.

Dans ce cours, nous expliquons pourquoi Java a adopté les expressions lambda : concision et lisibilité, passage du comportement en paramètre, intégration avec les collections et Stream API ( filter, map, forEach), capture des variables « effectivement » final et écriture pratique de callbacks via l’opérateur ->. En parallèle, nous verrons les écueils : débogage de longues chaînes, ambiguïté des surcharges ( Runnable vs Callable), limitations des closures, sérialisation et lambdas imbriquées. Enfin — des recommandations pratiques sur quand utiliser les lambdas et une analyse des erreurs typiques.

Dans ce cours, nous expliquons ce qu’est une fermeture et comment elle fonctionne en Java : comment les lambdas et les classes anonymes « capturent » des variables externes, pourquoi les variables locales doivent être final ou effectivement final, en quoi la capture de variables locales diffère de l’accès aux champs d’une classe, et comment se comporte this dans les lambdas et les classes anonymes. Nous montrerons des fabriques de fonctions avec IntSupplier, examinerons l’implémentation interne de la capture et les erreurs typiques (par exemple, le message du compilateur Variable used in lambda expression should be final or effectively final).

Dans ce cours, nous expliquons ce qu’est une classe anonyme en Java, en quoi elle diffère d’une expression lambda : syntaxe, possibilités (champs, méthodes supplémentaires, redéfinition de toString/ equals), portée et comportement de this, capture de variables (uniquement final/« effectivement final »). Des exemples pratiques avec Runnable, Comparator, Predicate sont présentés, ainsi que des recommandations — quand choisir une lambda et quand une classe anonyme.

Nous analysons les interfaces fonctionnelles clés du package java.util.function : Predicate, Consumer, Supplier, Function — ce qu’elles reçoivent/renvoient et où elles sont utilisées dans le Stream API ( filter, map, forEach, generate). Nous rappelons la règle « exactement une méthode abstraite » et l’annotation @FunctionalInterface, écrivons des lambdas, comparons avec les classes anonymes, pratiquons avec un exemple utilisant la classe User et passons en revue les erreurs typiques de choix entre Predicate/ Function, etc.

Cette leçon explique comment assembler des pipelines de transformations à partir de petites fonctions à l’aide de Function et de ses méthodes compose et andThen. Nous verrons l’ordre d’application, la compatibilité des types, des exemples avec Predicate ( and, or, negate), Consumer ( andThen), nous construirons des pipelines pratiques et discuterons des erreurs fréquentes: ordre inversé ( f.compose(g) vs f.andThen(g)), types incompatibles et « spaghetti » de chaînages. Vous apprendrez à utiliser apply, test, accept et à construire des transformations lisibles et réutilisables.

Introduction pratique au passage de comportements en Java : comment utiliser les expressions lambda ( ->) et les références de méthode ( ::) avec le Stream API et les collections. Nous passerons en revue les interfaces fonctionnelles standard de java.util.function — Comparator, Predicate, Function, Consumer, Supplier — nous apprendrons à écrire des méthodes générales, à accepter un comportement comme paramètres et à éviter les erreurs courantes. Nous nous entraînerons sur des exemples avec Stream, Optional et nos propres utilitaires de traitement de listes.

Nous passons des boucles impératives aux pipelines déclaratifs de traitement de données avec la Stream API : nous examinons les opérations intermédiaires et terminales, l’évaluation paresseuse, la collecte des résultats via toList()/ collect, les opérations clés map, filter, sorted, flatMap, reduce, ainsi que les vérifications anyMatch/ allMatch/ noneMatch. Nous comparerons le style impératif et le style fonctionnel, verrons des exemples pratiques et des erreurs typiques, y compris l’usage inapproprié de forEach pour collecter des collections et l’emploi prématuré de parallelStream().

Les 10 erreurs les plus fréquentes avec les lambdas et le Stream API en Java : capture de variables ( final/ effectively final), comportement de this dans les lambdas, effets de bord et parallélisme ( parallelStream()), inférence de types et generics, gestion de null et Optional, composition de fonctions ( compose/ andThen), ainsi que les exceptions vérifiées (par exemple, IOException). Nous montrons des pratiques sûres : filtrage Objects::nonNull, opérations terminales ( sum(), collect(...)), collections sûres pour les threads et décomposition de longues chaînes.

Comment fonctionne le modèle événementiel en Java : une source génère un événement, et les écouteurs abonnés reçoivent une notification et réagissent. Nous passerons en revue les interfaces d’écouteurs clés de Swing — ActionListener, MouseListener, KeyListener, ChangeListener, DocumentListener — et montrerons comment enregistrer des gestionnaires d’événements via addActionListener et implémenter la méthode actionPerformed. Nous nous exercerons à connecter des écouteurs à JButton/ JFrame, comparerons les classes anonymes et les expressions lambda, et discuterons des erreurs typiques et de conseils pratiques.

Brève introduction pratique au modèle d'événements AWT/ Swing : nous créons un bouton JButton, nous enregistrons un écouteur via addActionListener, nous traitons dans actionPerformed. Nous passons en revue les classes anonymes et les expressions lambda, les écouteurs populaires ( MouseListener/ MouseAdapter, KeyAdapter, DocumentListener), nous écrivons une mini-application basée sur JFrame, JButton, JLabel, nous examinons la séquence des appels et les erreurs typiques (travail lourd dans le gestionnaire, caractère final des variables dans les lambdas, addActionListener oublié, suppression des écouteurs, utilisation de SwingWorker).

Dans cette leçon, nous expliquons comment concevoir des événements personnalisés en Java : nous créons une classe d’événement basée sur java.util.EventObject, nous décrivons une interface d’écouteur via java.util.EventListener, nous ajoutons un mécanisme d’abonnement/désabonnement ( add...Listener/ remove...Listener) et de notification ( fire...). Nous verrons la pratique avec des exemples de DataLoader et d’un compteur, discuterons des gestionnaires sous classes anonymes et expressions lambda, et passerons en revue les erreurs typiques (exceptions dans les écouteurs, fuites de mémoire, ConcurrentModificationException).