Analyse du code source de l'expression lambda au niveau de la nounou Java8

1. Remplacement des classes internes anonymes

Il ne fait aucun doute que l'occasion la plus couramment utilisée pour les expressions lambda est de remplacer des classes internes anonymes, et l'implémentation de l'interface Runnable est un exemple classique de classes internes anonymes. Les expressions Lambda sont assez puissantes. Vous pouvez utiliser ()-> pour remplacer toute la classe interne anonyme ! Veuillez regarder le code :

Si vous utilisez une classe interne anonyme :

    @Test
    public void oldRunable() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("The old runable now is using!");
            }
        }).start();
    }

Et si vous utilisez une expression lambda :

    @Test
    public void runable() {
        new Thread(() -> System.out.println("It's a lambda function!")).start();
    }

La sortie finale :

L'ancien runable utilise maintenant !

C'est une fonction lambda !

Oui N'est-ce pas terriblement puissant ? Est-ce terriblement simple ? Est-ce terriblement clair et ciblé ? C'est ce qui fait peur avec les expressions lambda. Elles utilisent très peu de code pour accomplir ce que la classe précédente a fait !

2. Utilisez des expressions lambda pour parcourir les collections

Les classes de collection Java sont souvent utilisées dans le développement quotidien, et on dit même qu'il n'y a pas de code Java qui n'utilise pas de classes de collection. . . L’opération la plus courante sur les classes de collection est le parcours itératif. Veuillez consulter la comparaison :

    @Test
    public void iterTest() {
        List<String> languages = Arrays.asList("java","scala","python");
        //before java8
        for(String each:languages) {
            System.out.println(each);
        }
        //after java8
        languages.forEach(x -> System.out.println(x));
        languages.forEach(System.out::println);
    }

Si vous connaissez scala, vous devez connaître forEach. Il parcourt tous les objets de la collection et y introduit des expressions lambda.

languages.forEach(System.out::println);

Cette ligne ressemble un peu à la façon dont la résolution de portée est écrite en C++, et c'est également possible ici.

3. Utilisez des expressions lambda pour implémenter map

Quand il s'agit de programmation fonctionnelle et d'expressions lambda, comment ne pas mentionner map. . . Oui, Java8 est définitivement pris en charge. Veuillez consulter l'exemple de code :

    @Test
    public void mapTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        cost.stream().map(x -> x + x*0.05).forEach(x -> System.out.println(x));
    }

Le résultat final :

10.5

21.0

31.5

La fonction map peut être considérée comme la méthode la plus importante dans la programmation fonctionnelle. La fonction de la carte est de transformer un objet en un autre. Dans notre exemple, le coût est augmenté de 0,05 fois la taille grâce à la méthode cartographique, puis à la sortie.

4. Utilisez des expressions lambda pour implémenter map et réduire

Puisque map est mentionné, comment pouvons-nous ne pas mentionner réduire. Comme map, la réduction est également l’une des méthodes les plus importantes en programmation fonctionnelle. . . La fonction de map est de changer un objet en un autre, tandis que la fonction de reduction est de fusionner toutes les valeurs en une seule. Veuillez voir :

    @Test
    public void mapReduceTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        double allCost = cost.stream().map(x -> x+x*0.05).reduce((sum,x) -> sum + x).get();
        System.out.println(allCost);
    }

Le résultat final est :

63.0

Si nous utilisons un for. boucle pour le faire Cette question :

    @Test
    public void sumTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0);
        double sum = 0;
        for(double each:cost) {
            each += each * 0.05;
            sum += each;
        }
        System.out.println(sum);
    }

Je crois que la façon d'écrire l'expression map+reduce+lambda est plus d'un niveau plus haut.

5.fonctionnement du filtre

le filtre est aussi une opération que nous utilisons souvent. Lors de l’exploitation d’une collection, il est souvent nécessaire de filtrer certains éléments de la collection originale.

    @Test
    public void filterTest() {
        List<Double> cost = Arrays.asList(10.0, 20.0,30.0,40.0);
        List<Double> filteredCost = cost.stream().filter(x -> x > 25.0).collect(Collectors.toList());
        filteredCost.forEach(x -> System.out.println(x));

    }

Le résultat final :

30.030.0

40.0

40.0

    public static void filterTest(List<String> languages, Predicate<String> condition) {
        languages.stream().filter(x -> condition.test(x)).forEach(x -> System.out.println(x + " "));
    }

    public static void main(String[] args) {
        List<String> languages = Arrays.asList("Java","Python","scala","Shell","R");
        System.out.println("Language starts with J: ");
        filterTest(languages,x -> x.startsWith("J"));
        System.out.println("\nLanguage ends with a: ");
        filterTest(languages,x -> x.endsWith("a"));
        System.out.println("\nAll languages: ");
        filterTest(languages,x -> true);
        System.out.println("\nNo languages: ");
        filterTest(languages,x -> false);
        System.out.println("\nLanguage length bigger three: ");
        filterTest(languages,x -> x.length() > 4);
    }

Le langage commence par J :

Java

Le langage se termine par un :
Java

scala

Toutes les langues :
Java
Python
scala
Shell

R

Aucune langue :

Longueur du langage trois plus grandes :
Python
scala

Shell

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!