Java: Les expressions lambda

Vous avez surement entendu parler de la programmation fonctionnelle.

C'est l'un des nombreux paradigmes ou styles de programmation qui permet d'écrire du code lisible, et en moins de lignes.

Les expressions lambda ont été introduit en Java 8 pour permettre l'utilisation de ce paradigme de programmation en java.

Pour une meilleure compréhension des expressions lambda en Java nous parlerons des interfaces fonctionnelles puis nous attaqueront le vif du sujet.

Les interfaces fonctionnelles

Une interface est dite fonctionnelle si elle ne contient qu'une seule méthode abstraite.

Exemple 1:

public interface Ianimal{
    void walk();
}

Exemple 2:

public interface Ianimal{
    void walk();
    default void eat(){
        System.out.println("can eat 🍔");
    }
}

Notez bien que dans l'Exemple 2 malgré la présence d'une deuxième méthode eat l'interface reste fonctionnelle car la méthode étant marqué default n'est donc plus abstraite.

Maintenant que vous comprenez bien la notion d'interface fonctionnelle, considérons le bout de code suivant:

public class Main{
    public static void main(String[] args) {
        //Comment faire appelle à la methode show ici ?
    }
    static void show(Ianimal animal) {
        animal.walk()
    }
}

Nous avons trois manières d'appeler notre méthode show dans la méthode main de notre programme principal.

En créant une classe qui implémente l'interface

public class Dog implements Ianimal {
    @Override
    public void walk() {
        System.out.println("Walk with 4 legs");
    }
}

public class Main{
    public static void main(String[] args) {
        show(new Dog());
    }

    static void show(Ianimal animal) {
        animal.walk()
    }
}

Ce qui ne va pas avec cette manière de faire, est que nous avons crée une classe Dog (à usage unique en plus) qui implémente l'interface Ianimal pour juste effectuer quelque chose d'assez simple.

En utilisant les classes anonymes

public class Main{
    public static void main(String[] args) {
        show(new Ianimal() {
            @Override
            public void walk() {
               System.out.println("Walk with 4 legs");
            }
        });
    }

    static void show(Ianimal animal) {
        animal.walk()
    }
}

Avec les classes anonymes, certes nous avons évité la création d'une nouvelle classe.

Mais vous conviendriez avec moi que ce code, en plus d'être illisible est inutilement bavard pour exprimer quelque chose d'aussi simple.

C'est là où interviennent les expressions lambdas.

Utilisation des expressions lambda

public class Main{
    public static void main(String[] args) {
        show(()->{
           System.out.println("Walk with 4 legs");
        });
    }
    static void show(Ianimal animal) {
        animal.walk()
    }
}

Plus lisible et moins bavard non ?

Explication

Concentrons-nous sur l'essentiel observer bien l'appel de la fonction show avec

les classes anonymes:

show(new Ianimal() {
    @Override
    public void walk() {
        System.out.println("Walk with 4 legs");
    }
});

L'utilisation d'une expression lambda est possible grâce au caractère fonctionnelle de Ianimal.

Comme l'interface n'a qu'une seule méthode abstraite, Java nous propose ici d'omettre le nom de l'interface (Ianimal) et le nom de la fonction (walk) ce qui donne:

show(()->{
    System.out.println("Walk with 4 legs");
});

Plus loin encore, si le corps de la méthode ne contient qu'une seule instruction on peut se passer des accolades:

show(()-> System.out.println("Walk with 4 legs"));

On peut aussi renseigner les arguments de la fonction s'il y en avait par exemple:

show((arg)-> System.out.println(param));

Enlevé les parenthèses autour de arg si la fonction ne prend qu'un seul argument:

show(arg -> System.out.println(param));

Conclusion

Nous avons vu dans cet article l'utilité des expressions lambda, la compréhension de celle-ci va permettre d'appréhender la programmation fonctionnelle en Java dont nous parlerons dans notre prochain article.