Introduction

Dans ce cours, nous plongerons dans deux fonctionnalités révolutionnaires de Java : les expressions lambda et les références sur méthodes. Introduites dans Java 8, ces fonctionnalités ont transformé la façon dont nous écrivons du code en Java, offrant une programmation plus concise, élégante et expressive.

Objectifs du Cours :

• Comprendre ce que sont les expressions lambda et les références sur méthodes, ainsi que leur utilité dans le développement logiciel.
• Apprendre à utiliser ces fonctionnalités pour simplifier et clarifier le code Java.
• Explorer les bonnes pratiques et les cas d’utilisation appropriés des expressions lambda et des références sur méthodes.

À qui s’adresse ce Cours :

Ce cours s’adresse aux développeurs Java de tous niveaux qui souhaitent maîtriser les fonctionnalités avancées de Java 8 et versions ultérieures. Que vous soyez débutant ou expérimenté, ce cours vous aidera à tirer le meilleur parti des expressions lambda et des références sur méthodes dans vos projets Java.

Pourquoi les Expressions Lambdas et les Références sur Méthodes sont-elles importantes ?

Avant Java 8, l’écriture de code Java nécessitait souvent de créer des classes anonymes pour implémenter des interfaces fonctionnelles simples, ce qui pouvait entraîner une syntaxe lourde et verbeuse. Les expressions lambda sont venues résoudre ce problème en offrant une syntaxe concise pour créer des instances d’interfaces fonctionnelles.

Les références sur méthodes, quant à elles, permettent de référencer directement une méthode existante plutôt que de créer une nouvelle instance d’interface fonctionnelle. Cela simplifie encore plus le code et le rend plus lisible.

Exemple concret :

Supposons que nous ayons une liste d’entiers que nous voulons trier en utilisant un comparateur personnalisé. Avant Java 8, cela impliquerait la création d’une classe anonyme pour implémenter l’interface Comparator.

Avec les expressions lambda, le code ressemblerait à ceci :

List<Integer> nombres = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5);
Collections.sort(nombres, (a, b) -> a.compareTo(b));

Ici, (a, b) -> a.compareTo(b) est une expression lambda qui représente un comparateur personnalisé pour trier les entiers dans l’ordre croissant.

Les références sur méthodes nous permettraient d’écrire le même code de manière encore plus concise :

Collections.sort(nombres, Integer::compareTo);

Dans ce cas, Integer::compareTo fait référence à la méthode compareTo de la classe Integer.

Fondements des Expressions Lambdas

Les expressions lambda sont une fonctionnalité clé introduite dans Java 8, permettant de simplifier la syntaxe pour créer des instances d’interfaces fonctionnelles. Dans cette section, nous allons explorer en détail ce que sont les expressions lambda, leur syntaxe et leur utilisation.

1. Définition des Expressions Lambdas

Les expressions lambda sont des fonctions anonymes qui peuvent être utilisées pour créer des instances d’interfaces fonctionnelles. Elles sont souvent utilisées pour simplifier le code en évitant la nécessité de créer des classes anonymes pour implémenter des interfaces fonctionnelles simples.

Exemple d’une expression lambda en Java :

() -> System.out.println("Bonjour !");

Dans cet exemple, () -> System.out.println("Bonjour !") est une expression lambda qui représente une fonction prenant aucun argument et affichant « Bonjour ! » à la sortie standard.

2. Syntaxe des Expressions Lambdas

La syntaxe d’une expression lambda est concise et se compose des éléments suivants :

• Liste des paramètres (facultative) : entre parenthèses et séparée par des virgules.
• Opérateur de lambda (->) : sépare la liste des paramètres du corps de la lambda.
• Corps de la lambda : contient les instructions de la fonction.

Exemple de syntaxe d’une expression lambda :

(paramètres) -> expression

ou

(paramètres) -> { instructions; }

3. Utilisation des Expressions Lambdas

Les expressions lambda sont souvent utilisées dans des contextes où une interface fonctionnelle est attendue, tels que les méthodes prenant des interfaces fonctionnelles en paramètres ou les opérations sur les streams.

Exemple d’utilisation d’une expression lambda avec la méthode forEach d’une liste :

List<String> mots = Arrays.asList("Bonjour", "à", "tous");
mots.forEach(mot -> System.out.println(mot));

Dans cet exemple, mot -> System.out.println(mot) est une expression lambda passée à la méthode forEach pour afficher chaque élément de la liste mots.

4. Avantages des Expressions Lambdas

Les expressions lambda offrent plusieurs avantages, notamment :

• Syntaxe concise : permet de réduire le code en évitant la nécessité de créer des classes anonymes.
• Lisibilité améliorée : rend le code plus lisible en exprimant de manière concise l’intention du programmeur.
• Flexibilité : permet une programmation plus expressive et fonctionnelle en Java.

Les expressions lambdas sont un outil puissant pour écrire un code plus propre, plus lisible et plus expressif en Java. Dans la prochaine partie, nous explorerons des fonctionnalités avancées des expressions lambda, y compris les captures de variables et les différents types de fonctions lambda.

Fonctionnalités Avancées des Expressions Lambdas

Dans cette partie, nous explorerons des fonctionnalités avancées des expressions lambdas, telles que les captures de variables et les différents types de fonctions lambda.

1. Captures de Variables (Variable Capturing)

Les expressions lambdas peuvent accéder et capturer les variables locales et de champ (instance ou statique) de leur portée. Les variables capturées doivent être effectivement finales ou implicitement finales, c’est-à-dire qu’elles ne doivent pas être modifiées après avoir été capturées par une lambda.

Exemple d’une capture de variable dans une expression lambda :

int a = 10;
Consumer<Integer> consumer = x -> System.out.println(x + a);

Dans cet exemple, la variable a est capturée par la lambda et peut être utilisée à l’intérieur de la lambda.

2. Types de Fonctions Lambda

Il existe différents types de fonctions lambda en Java, en fonction du nombre de paramètres et du type de retour.

2.1. Fonctions Lambda avec Paramètres et Retour

Exemple d’une fonction lambda avec paramètres et retour :

Function<Integer, Integer> doubler = x -> x * 2;

Cette lambda prend un entier en entrée et renvoie son double.

2.2. Fonctions Lambda sans Paramètres et sans Retour

Exemple d’une fonction lambda sans paramètres et sans retour :

Runnable runnable = () -> System.out.println("Exécution");

Cette lambda ne prend aucun argument et ne renvoie rien.

2.3. Fonctions Lambda à Affectation de Méthodes

Les méthodes existantes peuvent être référencées dans une lambda à l’aide de l’opérateur de référence ::.

Exemple d’une fonction lambda utilisant une référence de méthode :

Function<String, Integer> longueur = String::length;

Cette lambda renvoie la longueur d’une chaîne de caractères.

3. Avancées des Expressions Lambdas

Les expressions lambdas offrent une flexibilité et une expressivité considérables dans la programmation Java. En combinant ces fonctionnalités avec les captures de variables et les différents types de fonctions lambda, les développeurs peuvent écrire un code plus concis et plus lisible.

Introduction aux Références sur Méthodes

Les références sur méthodes sont une fonctionnalité introduite dans Java 8 qui permet de référencer une méthode existante sans l’appeler. Elles offrent une syntaxe concise pour créer des instances d’interfaces fonctionnelles, en particulier lorsque la méthode référencée correspond à la signature de l’interface fonctionnelle attendue.

1. Définition des Références sur Méthodes

Une référence sur méthode est une expression qui identifie une méthode sans l’invoquer. Elles peuvent être utilisées pour remplacer les lambdas lorsque la méthode lambda ne fait que appeler une méthode existante.

Exemple de référence sur méthode en Java :

Function<String, Integer> longueur = String::length;

Dans cet exemple, String::length est une référence sur méthode qui fait référence à la méthode length() de la classe String.

2. Syntaxe des Références sur Méthodes

La syntaxe d’une référence sur méthode dépend du contexte dans lequel elle est utilisée. Il existe quatre types de références sur méthodes :

2.1. Références sur Méthodes Statiques

Conteneur::méthodeStatique

2.2. Références sur Méthodes d’Instance d’un Objet Particulier

objet::méthodeInstance

2.3. Références sur Méthodes d’Instance d’un Objet Arbitraire d’un Type Spécifique

Type::méthodeInstance

2.4. Références sur Constructeurs

Type::new

3. Utilisation des Références sur Méthodes

Les références sur méthodes peuvent être utilisées dans les mêmes contextes que les expressions lambda, notamment comme arguments de méthodes qui prennent des interfaces fonctionnelles en paramètres, telles que les méthodes map(), filter(), reduce(), etc., des streams.

Exemple d’utilisation d’une référence sur méthode avec la méthode map() d’un stream :

List<String> mots = Arrays.asList("Bonjour", "à", "tous");
Stream<Integer> longueurs = mots.stream().map(String::length);

Dans cet exemple, String::length est une référence sur méthode passée à la méthode map() pour obtenir la longueur de chaque élément de la liste mots.

Les références sur méthodes offrent une syntaxe concise et expressive pour appeler des méthodes existantes, ce qui simplifie le code et améliore la lisibilité.

Utilisation Pratique des Expressions Lambdas et des Références sur Méthodes

Dans cette partie, nous explorerons des exemples concrets d’utilisation des expressions lambdas et des références sur méthodes dans des contextes pratiques.

1. Programmation Fonctionnelle en Java

Les expressions lambdas et les références sur méthodes sont largement utilisées dans la programmation fonctionnelle en Java, notamment avec l’utilisation de la classe java.util.function et les opérations sur les streams.

Exemple d’utilisation des expressions lambdas avec les streams pour filtrer et mapper une liste d’entiers :

List<Integer> nombres = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> doubles = nombres.stream()
                              .filter(x -> x % 2 == 0)
                              .map(x -> x * 2)
                              .collect(Collectors.toList());

2. Intégration avec les APIs Java Standard

Les expressions lambdas et les références sur méthodes peuvent être utilisées avec les APIs Java standard pour simplifier les opérations courantes, telles que la manipulation de collections, les opérations sur les threads, et les opérations sur les fichiers.

Exemple d’utilisation d’une référence sur méthode avec la méthode forEach() d’une liste pour afficher chaque élément :

List<String> mots = Arrays.asList("Bonjour", "à", "tous");
mots.forEach(System.out::println);

3. Avantages

• Concision du Code : Les expressions lambdas et les références sur méthodes permettent de réduire considérablement le nombre de lignes de code, ce qui le rend plus lisible et plus concis.
• Expressivité : Elles permettent d’exprimer l’intention du programmeur de manière claire et concise, ce qui facilite la compréhension du code.
• Modularité : Elles favorisent une approche modulaire de la programmation en permettant de décomposer le code en petites unités réutilisables.

Exercices d’application

Exercice 1: Filtrage d’une liste

Écrivez une méthode qui prend une liste de nombres entiers et utilise une expression lambda pour filtrer et renvoyer uniquement les nombres pairs.

Correction

import java.util.List;
import java.util.stream.Collectors;

public class LambdaExercises {
    public static List<Integer> filtrerNombresPairs(List<Integer> nombres) {
        return nombres.stream()
                      .filter(n -> n % 2 == 0)
                      .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<Integer> nombres = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> nombresPairs = filtrerNombresPairs(nombres);
        System.out.println("Nombres pairs: " + nombresPairs);
    }
}

Exercice 2: Calcul de la somme

Écrivez une méthode qui prend une liste de nombres entiers et utilise une expression lambda pour calculer la somme de tous les éléments de la liste.

Correction

import java.util.List;

public class LambdaExercises {
    public static int calculerSomme(List<Integer> nombres) {
        return nombres.stream()
                      .reduce(0, Integer::sum);
    }

    public static void main(String[] args) {
        List<Integer> nombres = List.of(1, 2, 3, 4, 5);
        int somme = calculerSomme(nombres);
        System.out.println("Somme: " + somme);
    }
}

Exercice 3: Conversion des chaînes en majuscules

Écrivez une méthode qui prend une liste de chaînes de caractères et utilise une expression lambda pour convertir toutes les chaînes en majuscules.

Correction

import java.util.List;
import java.util.stream.Collectors;

public class LambdaExercises {
    public static List<String> convertirEnMajuscules(List<String> chaines) {
        return chaines.stream()
                      .map(String::toUpperCase)
                      .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<String> chaines = List.of("Bonjour", "à", "tous");
        List<String> majuscules = convertirEnMajuscules(chaines);
        System.out.println("En majuscules: " + majuscules);
    }
}

Exercice 4: Filtrage avec condition multiple

Écrivez une méthode qui prend une liste de chaînes de caractères et utilise une expression lambda pour filtrer et renvoyer uniquement les chaînes qui commencent par une lettre majuscule et ont une longueur supérieure à 5 caractères.

Correction

import java.util.List;
import java.util.stream.Collectors;

public class LambdaExercises {
    public static List<String> filtrerChaines(List<String> chaines) {
        return chaines.stream()
                      .filter(s -> Character.isUpperCase(s.charAt(0)) && s.length() > 5)
                      .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        List<String> chaines = List.of("Bonjour", "à", "Tous", "Java", "Lambda", "Exercises");
        List<String> resultat = filtrerChaines(chaines);
        System.out.println("Résultat du filtrage: " + resultat);
    }
}

Exercice 5: Tri selon une propriété

Écrivez une méthode qui prend une liste d’objets de type Personne (avec les propriétés nom et age) et utilise une expression lambda pour trier la liste par âge croissant.

Correction

import java.util.Comparator;
import java.util.List;

public class LambdaExercises {
    static class Personne {
        String nom;
        int age;

        public Personne(String nom, int age) {
            this.nom = nom;
            this.age = age;
        }
        
        public String toString() {
            return nom + " (" + age + ")";
        }
    }

    public static void trierParAge(List<Personne> personnes) {
        personnes.sort(Comparator.comparingInt(p -> p.age));
    }

    public static void main(String[] args) {
        List<Personne> personnes = List.of(
            new Personne("Alice", 30),
            new Personne("Bob", 25),
            new Personne("Charlie", 35)
        );

        trierParAge(personnes);
        System.out.println("Personnes triées par âge: " + personnes);
    }
}

Exercice 6: Vérification de la présence d’éléments

Écrivez une méthode qui prend une liste de nombres entiers et utilise une expression lambda pour vérifier si un nombre donné est présent dans la liste.

Correction

import java.util.List;

public class LambdaExercises {
    public static boolean verifierPresence(List<Integer> nombres, int nombre) {
        return nombres.stream().anyMatch(n -> n == nombre);
    }

    public static void main(String[] args) {
        List<Integer> nombres = List.of(1, 2, 3, 4, 5);
        int nombre = 3;
        boolean present = verifierPresence(nombres, nombre);
        System.out.println("Le nombre " + nombre + " est présent dans la liste: " + present);
    }
}

Bonnes Pratiques et Limitations des Expressions Lambdas et des Références sur Méthodes

Dans cette partie, nous aborderons les bonnes pratiques à suivre lors de l’utilisation des expressions lambdas et des références sur méthodes, ainsi que les limitations à prendre en compte.

1. Bonnes Pratiques

• Clarté et Lisibilité : Utilisez des noms de variables significatifs pour améliorer la compréhension du code. Évitez les expressions lambdas trop complexes.
• Évitez les Effets Secondaires : Les expressions lambdas ne doivent pas modifier les variables externes ou avoir des effets secondaires imprévisibles.
• Utilisation Appropriée : Utilisez les expressions lambdas lorsque cela simplifie le code et améliore la lisibilité. Ne les utilisez pas de manière excessive.

2. Limitations

• Portée des Variables Capturées : Faites attention à la portée des variables capturées par les expressions lambdas, surtout si elles sont modifiées après la capture.
• Sécurité : Assurez-vous que les expressions lambdas sont utilisées de manière sécurisée pour éviter les vulnérabilités potentielles, telles que les fuites de ressources ou les accès non autorisés.
• Performance : Les expressions lambdas peuvent entraîner une légère surcharge de performance par rapport à l’appel direct de méthodes. Cependant, cette surcharge est généralement négligeable dans la plupart des cas.

3. Considérations Additionnelles

• Compatibilité : Les expressions lambdas et les références sur méthodes sont disponibles à partir de Java 8. Assurez-vous que votre environnement de développement et votre plateforme d’exécution prennent en charge Java 8 ou une version ultérieure.
• Évolutivité : Pensez à l’évolutivité de votre code lorsque vous utilisez des expressions lambdas et des références sur méthodes. Assurez-vous qu’il reste facile à maintenir et à étendre à mesure que les exigences de votre application évoluent.

Conclusion

Les expressions lambdas et les références sur méthodes sont des fonctionnalités puissantes de Java qui permettent d’écrire un code plus propre, plus concis et plus lisible. En suivant les bonnes pratiques et en tenant compte des limitations, vous pouvez exploiter pleinement le potentiel de ces fonctionnalités dans vos projets Java.