Analyse d'un exemple d'expression Java Lambda

1. Introduction

Tout d'abord, l'expression Lambda est une nouvelle fonctionnalité de Java8. Elle prend en charge la programmation fonctionnelle dans la programmation Java, aide à simplifier le code et peut remplacer la plupart des fonctions anonymes, en particulier pour. Les opérations de parcours de collection et de collecte simplifient considérablement le code.

Le corps principal de l'expression Lambda :

Interface fonctionnelle :

Remarque : l'expression Lambda doit être utilisée avec une interface fonctionnelle. L'interface dite fonctionnelle signifie qu'une interface avec une seule méthode abstraite dans l'interface est fonctionnelle. . Nous pouvons personnaliser l'interface et JDK dispose également d'un grand nombre d'interfaces fonctionnelles intégrées.

1. L'annotation @FunctionalInterface modifie l'interface, alors cette interface est une interface fonctionnelle, qui ne peut avoir qu'une seule méthode :

@FunctionalInterface
public interface MyInteface {

    void eat();

}

2. , vous êtes dans l'interface L'écriture d'une seule méthode abstraite peut également être considérée comme une interface fonctionnelle :

public interface MyInteface {
    void eat();
}

C'est également possible.

3. Il n'y a qu'un seul cas où les interfaces fonctionnelles ont plus que des méthodes abstraites, et c'est la méthode qui peut hériter de la classe Object :

@FunctionalInterface
public interface MyInteface3 {

    void eat();

    @Override
    String toString();
    
    @Override
    int hashCode();
}

2 L'utilisation d'expressions Lambda :

1.

Classe d'étudiant :

@FunctionalInterface
public interface Student {

    void eat();

}

Classe de test :

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

        Student stu = new Student() {

            //普通方法，重写并使用
            @Override
            public void eat() {
                System.out.println("我是学生");
            }
        };
        stu.eat();


        //lambda表达式写法：
        //参数1:重写了Student接口中唯一的那个无参数的eat抽象方法做了具体的实现，所以重写不 需要署名
        //参数2:-> 表达式 固定的
        //参数3：{具体的实现} 对Student接口中唯一的eat方法做了具体的实现
            Student stu2 = () -> {
                System.out.println("学生吃饭");
            };
        stu2.eat();
        
    }
}

Sortie :

Je suis étudiant
Les étudiants mangent

Utilisation de méthodes avec paramètres

Classe d'étudiant :

@FunctionalInterface
public interface Student {

    void eat(String food);
}

Classe de test :

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

        //lambda重写Student接口唯一的有参方法：
        Student stu2 = (foodName)->{
            System.out.println("学生在吃"+foodName);
        };

        stu2.eat("肉");
    }
}

//Sortie : les étudiants mangent de la viande

3. Expressions Lambda pour implémenter le multi-threading

La méthode de création de multi-threads a été présentée dans l'article sur le multi-threading (1). Ici, nous utilisons lambda pour créer des threads. :

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

        Thread t = new Thread(() -> {
            System.out.println("这个线程是由lambda来创建的");
        });

        t.start();

    }
}

4, Opérations d'opération d'expression Lambda

Nous pouvons utiliser lambda pour opérer des opérations et économiser beaucoup de code :

Interface fonctionnelle :

@FunctionalInterface
public interface Calculator<T> {

    T operation(T v1,T v2);

}

Classe de test :

public class Test {

    //计算方法
    public static Integer operator(Integer v1,Integer v2,Calculator<Integer> calculator){
        return calculator.operation(v1, v2);
    }

    public static void main(String[] args) {


        //使用lambda表达式：
        //这里的意思就是传入两个参数，返回运行后的值
        int add = Test.operator(5,10,(x,y)->{
            return x+y;
        });


        //简写：可以少写很多代码，比上面更简介了
        int num1 = Test.operator(5,10,(x,y)->x+y);
        int num2 = Test.operator(10,5,(x,y)->x-y);

        System.out.println(add);
        System.out.println(num1);
        System.out.println(num2);

    }
}

Sortie :

15, 15, 5

5, Référence de la méthode Lambda Expression

Parfois, nous n'avons pas besoin de réécrire la méthode d'interface pour réaliser une implémentation spécifique. Si nous avons une méthode existante pour l'implémenter, nous pouvons également référencer la méthode existante dans l'interface via la méthode. référence. L'avantage de l'implémentation spécifique de la méthode est la réutilisation de code, tel que le suivant :

Interface fonctionnelle :

public interface ResultOneParam {

    int method(int a);
}

Classe de test :

public class Test {

    public int addTo(int a){
        return  a+10;
    }

    public  static int addTo2(int a){
        return  a+10;
    }

    public static void main(String[] args) {
        //lambda重写了method方法
        ResultOneParam lambda1=(a)->a+10;

        //方法引用：就是在Test里面的addTo2方法用来替代method被重写的方法
        ResultOneParam lambda2= Test::addTo2;
        int result1= lambda2.method(9);
        System.out.println(result1);

        //方法引用 ::引用现成的方法来替代方法重写，这样可以方法重用
        Test test=new Test();
        ResultOneParam lambda3=test::addTo;
        int result2= lambda3.method(9);
        System.out.println(result1);

    }
}

6. L'utilisation d'expressions Lambda sur les collections

Bien sûr, Lambda aussi. fonctionne sur les collections Très pratique et économise beaucoup de code :

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

        List<Integer> list = Arrays.asList(5,1,3,4,5,0,9,7,0,1,5);

        //lambda表达式遍历集合，重写了Consumer接口的方法
        list.forEach((element)->{
            System.out.println(element);
        });

        //简写：
        list.forEach(element-> System.out.println(element));

        //lambda表达式方法引用，用于遍历输出list集合:
        list.forEach(System.out::print);

        //输出list的偶数:
        list.forEach(element->{
            if(element%2==0){
                System.out.println(element);
            }

        });
    }
}

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!