Testons et apprenons la compréhension des expressions Lambda en Java

Chat :

Cela fait longtemps que JDK8 n'est pas sorti, j'en ai appris un peu lors de sa première sortie, puis je l'ai abandonné, et. maintenant je le reprends. Bien qu'il s'agisse désormais de JDK11.

Cet article sera mis à jour en permanence.

Texte :

Regardez directement le code Dans les nouvelles fonctionnalités de java8, on peut écrire comme ceci :

public static void main(String[] args) {
        Supplier<Integer> supplier = ()->1;
        Consumer<String> consumer = (a)-> System.out.println(a);
        System.out.println(supplier.get());
        consumer.accept("test");
    }

Sortie :

1
test

Process finished with exit code 0

Style très occidental. Pouvez-vous faire un code aussi concis ? Oui, cela signifie que vous java7

Volez d'abord une image et expliquez Lambda

En d'autres termes, l'expression Lambda, crée une implémentation de l'interface correspondante, puis l'attribue à la variable Utilise-t-elle le compilateur ? Vérifiez le code compilé comme suit :

public static void main(String[] args) {
        Supplier<Integer> supplier = () -> {
            return 1;
        };
        Consumer<String> consumer = (a) -> {
            System.out.println(a);
        };
        System.out.println(supplier.get());
        consumer.accept("test");
    }

Le compilateur ne fait pas cette fonction, il se peut donc que la JVM ait implémenté la fonction Lambda. Nous en apprendrons plus plus tard. Mark 1

Écrit ici, vous pouvez savoir que les expressions Lambda réduisent la quantité de code. Avant Java8, vous ne pouviez utiliser que des classes internes anonymes ou créer une classe pour implémenter l'interface pour réaliser cette fonction. Comme suit

Supplier<Integer> supplier = new Supplier<Integer>() {
            @Override
            public Integer get() {
                return 1;
            }
        };

En fait, je suis plus curieux de connaître l'interface qui accompagne Lambda. Ouvrez le code source et vous pouvez voir

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

对应的接口都添加了注解FunctionalInterface，那么不要这个注解是否能实现Lambda表达式，我做了一些测试，发现不需要注解也可以实现，目前来看注解只有两个功能 
1、表示这个接口是函数式接口 2、帮助编译器识别，接口不能有多个方法。
在有多个方法的时候会提示Multiple non-overriding abstract methods found in interface

Maintenant, nous pouvons utiliser FunctionalInterface pour trouver. ce qu'il y a dans JDK8 L'interface est une interface fonctionnelle

J'en choisis un ou deux populaires pour tester et apprendre

Oh, interromps-moi d'abord et je il suffit de lire l'article. Sur un point très important (en pratique, les interfaces fonctionnelles sont très fragiles : tant qu'un développeur ajoute une fonction à l'interface, l'interface n'est plus une interface fonctionnelle et la compilation échoue. Afin de pallier cela fragilité au niveau du code, et indique explicitement qu'une interface est une interface fonctionnelle. Java 8 fournit une annotation spéciale)

J'ai choisi ArrayList etOptional, qui sont toutes deux des classes très couramment utilisées.

Articles connexes :

Compréhension approfondie des expressions Lambda en Java

Une exploration préliminaire des expressions Java Lambda

Vidéos associées :

Tutoriel vidéo sur les expressions régulières JavaScript

---

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!