Les expressions Lambda dans Java 8

Vous avez encore du mal à saisir les nouvelles expressions Lambda de Java 8? Vous n'êtes pas seul. Cet article vous aidera à voir comment faire fonctionner vos expressions Lambda.

Commençons par les expressions Lambda. Que sont-elles? Et comment elles fonctionnent?

J'ai googlé beaucoup de messages et de vidéos YouTube avant de comprendre les expressions lambda, mais j'ai trouvé cela difficile à comprendre parce que je n'avais jamais utilisé de langage fonctionnel auparavant. J'ai donc décidé d'écrire un article pour aider les gens comme moi.

Ne vous inquiétez pas pour le nom. C'est la même vieille programmation Java avec un peu de saveur différente. Il réduit simplement les mots requis pour écrire une fonction ou appeler une fonction ou écrire une classe anonyme.

Jetez un oeil à une syntaxe d'expression lambda:

Syntaxe:

1. (int a, int b) -> {return a + b; }
      1. Fonction avec deux paramètres.
      2. (a, b) -> {return a + b; } fonctionne de la même manière.

2. () -> System.out.println ("Hello World");
      1. Fonction sans paramètre.

3. (Chaîne s) -> {System.out.println (s); }
      1. Fonction avec un paramètre.

4. (s) -> System.out.println (s);
      1. Pas besoin de spécifier le type de paramètre.
      2. Aucun besoin d'accolades pour des déclarations simples.

5. () -> 42

6. () -> {return 3.1415};

Je suis sûr que certains programmeurs vont essayer d'écrire un programme "hello world" en utilisant la syntaxe de l'expression Lambda après avoir vérifié la syntaxe, comme ceci:

Class Test()

{

    public static void main(String[] args)

    {

        ()->System.out.println(“Hello world”);

    }

}

Je ne sais pas pour vous, mais je l'ai fait. Et trouvé ceci: "we can use lambda expressions only with Functional interfaces."

Q. Maintenant, qu'est-ce qu'une interface fonctionnelle et pourquoi est-ce important pour les expressions Lambda? 

==> Interface fonctionnelle: Une interface fonctionnelle est une interface avec une seule méthode abstraite. 

Exemple:

public interface FunctionalInterface

{

    public void show();

}

Comme vous pouvez le voir l'interface ci-dessus a seulement une méthode, ainsi c'est une interface fonctionnelle.

Maintenant, essayez d'écrire le programme "Hello world".

Voici une ancienne méthode avant les expressions Lambda:

public class TestFunInter {

    public static void main(String[] args) {

        FunctionalInterface f = new FunctionalInterface() {

            public void show() {

                System.out.println("hello world");

            }

        };

        f.show();

    }

}

Output:

hello world

ET

public class TestFunInter

{

    public static void main(String[] args)

    {

        new FunctionalInterface() {

            @Override

            public void show()

            {

                System.out.println("hello world");

            }

        }.show();

    }

}

Output:

hello world

Maintenant, voici la "façon" Lambda:

public class TestFunInter {

    public static void main(String[] args){

        FunctionalInterface f=()->System.out.println("hello world");

        f.show();

    }

}

Output:

hello world

Comparez toutes les façons d'écriture du même code, vous pouvez obtenir la bonne idée de ce que le Lambda fait pour vous. Maintenant, certains d'entre vous ont commencé à imaginer et pourraient maintenant poser une question comme "Pourquoi a-t-il besoin d'une interface fonctionnelle pour fonctionner?".

Cela signifie que chaque fois que nous voulons faire quelque chose en utilisant des expressions lambda, nous devons d'abord créer une interface fonctionnelle.

Les développeurs d'API ont déjà fourni de nombreuses interfaces fonctionnelles nécessaires pour une utilisation générale. Et ces interfaces sont situées dans le package java.util.function. Vous pouvez consulter ce lien pour plus de détails.

Jetons un coup d'œil au package java.util.function.

Exemple:

import java.util.function.*;

public class Test{

    public static void main(String[] args){

        BiConsumer<String, String> bi = (a, b) -> System.out.println(a + b);

        bi.accept("shiv ", "----------");

    }

}

Output:

-shiv----------

Vous pouvez voir dans l'exemple ci-dessus:

• import -> nous avons importé le paquet de fonction.
• Dans la méthode principale, nous avons créé une variable de référence de type interface avec deux types génériques.

Cette interface a une méthode abstraite qui accepte deux paramètres. et ne retourne rien. Vous pouvez vérifier les détails ici.

Expression Lambda avec des Threads

Note: Nous savons tous qu'une interface "Runnable" n'a qu'une seule méthode "run ()". Il s'agit donc également d'une "interface fonctionnelle" et peut être utilisé avec une expression Lambda.

Exemple 1: Utilisation du Thread type 1:

public class TestClass {

    public static void main(String[] args) {

        Runnable r = new Runnable() {

            public void run() {

                System.out.println("I am runnable thread");

            }

        };

        Thread t = new Thread(r);

        t.start();

    }

}

Faisons de même en utilisant une expression Lambda:

public class TestClass {

    public static void main(String[] args){

        Runnable r = () -> System.out.println("lambda expression");

        Thread t = new Thread(r);

        t.start();

    }

}

Exemple 2: Utilisation du Thread type 2:

public class TestClass {

    public static void main(String[] args){

        new Thread(new Runnable(){

            public void run(){

                System.out.println("thread");

            }

        }).start();

    }

}

Faisons de même en utilisant une expression Lambda:

public class TestClass {

    public static void main(String[] args){

        new Thread(()->System.out.println("lambda thread")).start();

    }

}

Il suffit de comparer les chemins standard et lambda, et vous pouvez trouver les choses plus faciles.

Ce que l'expression Lambda peut faire :

• Peut définir des fonctions anonymes
• Peut être affecté à une variable
• Peut être passé aux fonctions
• Peut être retourné des fonctions