[JAVA] Introduction au style lambda

Pourquoi utiliser l'expression lambda?

Java, qui est utilisé pour le développement à grande échelle, est nécessaire pour réduire autant que possible la quantité de code et le rendre plus facile à lire. L '"expression lambda" utilisée dans Java 8 est utile pour de telles occasions. Une caractéristique des expressions lambda est que vous pouvez traiter les méthodes comme des variables.

Comment écrire:

[Déclaration d'interface]= (argument)->{Bloc d'exécution}

Vérifions à partir du code source à la fois. Tout d'abord, l'expression traditionnelle:

public class LambdaTest {

    public static void main(String[] args) {
        //Expression traditionnelle
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("threading" + Thread.currentThread().getId());
            }
        }).start();
    }
}

Ce qui suit est une représentation de l'expression Lambda.

public class LambdaTest {

    public static void main(String[] args) {
        //Expression Lambda
        new Thread(() -> {
            System.out.println("Lambda threading" + Thread.currentThread().getId());
        }).start();
    }
}

Interface fonctionnelle Java

L'interface fonctionnelle de Java est presque la même qu'une interface traditionnelle, mais la seule caractéristique est que l'interface fonctionnelle est "une interface avec une seule méthode abstraite définie". Peu importe si des méthodes statiques ou des méthodes par défaut sont incluses. (C'est une bonne idée d'ajouter l'annotation java.lang.FunctionalInterface).

Veuillez vous référer à l'introduction détaillée de l'interface de la fonction Java. https://qiita.com/Jenny1025/items/470e304ff77c44874fc8

Exemple:

@FunctionalInterface
public interface UserIdentify {
    String verifyUser(String userName);
}

Avantages de la formule Lambda

L'avantage de l'expression Lambda de Java est qu'elle peut simplifier la description des interfaces fonctionnelles à l'aide de classes anonymes.

• Classe anonyme: une classe qui n'est utilisée qu'une seule fois

Classe anonyme:

public class App 
{
    public static void main( String[] args ) {

        //Interface fonctionnelle
        UserIdentify ic = new UserIdentify() {
            @Override
            public String verifyUser(String userName) {
                return "admin".equals(userName)? "admin":"member";
            }
        };

        System.out.println(ic.verifyUser("admin"));
        System.out.println(ic.verifyUser("manager"));
        }
    }

Alors, comment l'exprimez-vous dans la formule Lambda?

public class App {
    public static void main( String[] args ) {
        
        UserIdentify ic1 = (String userName) -> {
                return "admin".equals(userName)? "admin":"member";
            };
        System.out.println(ic1.verifyUser("admin"));
        System.out.println(ic1.verifyUser("manager"));
        }
    }

Plus précisément, explication de la façon d'écrire une expression lambda

1. Déclaration: type d'interface de style Lambda
2. Argument: entrez (). Identique au nombre et à l'ordre des arguments d'interface
3. Expression: ->
4. Bloc d'exécution: implémenter dans {}

Commençons par un exemple concret.

Aucun argument, aucune valeur de retour

public class App {
    public static void main( String[] args ) {

        //Aucun argument, aucune valeur de retour
        Lambda1 lambda1 = () -> System.out.println("Hello world");
        lambda1.test();
    }
    interface Lambda1 {
        void test();
    }
}

Résultat de la mise en œuvre: Hello world

Avec argument, pas de valeur de retour

public class App {
    public static void main( String[] args ) {

        //Avec argument, pas de valeur de retour
        Lambda2 lambda2 = (n, a) -> System.out.println(n + " is " + a + " years old");
        lambda2.test("Sally",18);
    }
    interface Lambda2 {
        void test(String name, Integer age);
    }
}

Résultat de la mise en œuvre: Sally a 18 ans

Avec argument, avec valeur de retour

public class App {
    public static void main( String[] args ) {

        //Avec argument, avec valeur de retour
        Lambda3 lambda3 = (a, b) -> a + b;
        System.out.println(lambda3.test(100,3000));
    }
    interface Lambda3 {
        int test(int a, int b);
    }
}

Résultat d'exécution: 3100