Analisis contoh ungkapan Java Lambda

1 Pengenalan

Pertama sekali, ungkapan Lambda ialah ciri baharu Java8, yang menyediakan sokongan untuk pengaturcaraan berfungsi dalam pengaturcaraan Java dan membantu Kesederhanaan. kod boleh menggantikan kebanyakan fungsi tanpa nama, terutamanya untuk operasi traversal dan pengumpulan koleksi, yang sangat memudahkan kod.

Isi badan ungkapan Lambda:

Antara muka berfungsi:

Nota: Ungkapan Lambda mesti digunakan dengan antara muka berfungsi Apa yang dipanggil antara muka berfungsi bermakna antara muka dengan hanya satu kaedah abstrak dalam antara muka ialah antara muka berfungsi. JDK juga mempunyai sejumlah besar antara muka berfungsi terbina dalam.

1. Anotasi @FunctionalInterface mengubah antara muka ini ialah antara muka berfungsi. Berikut ialah antara muka berfungsi:

@FunctionalInterface
public interface MyInteface {

    void eat();

}

2 tidak ditambah **Nota, jika anda menulis hanya satu kaedah abstrak dalam antara muka, ia juga boleh dianggap sebagai antara muka berfungsi:

public interface MyInteface {
    void eat();
}

Ini juga mungkin.

3. Hanya terdapat satu kes di mana antara muka berfungsi bukan sahaja mempunyai kaedah abstrak, iaitu, ia boleh mewarisi kaedah kelas Objek:

@FunctionalInterface
public interface MyInteface3 {

    void eat();

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

2 :

1. Gunakan dalam kaedah biasa

Kelas pelajar:

@FunctionalInterface
public interface Student {

    void eat();

}

Kelas ujian:

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();
        
    }
}

Output:

Saya seorang pelajar
Pelajar makan

2 Penggunaan kaedah dengan parameter

Kelas pelajar:

@FunctionalInterface
public interface Student {

    void eat(String food);
}

Kelas ujian:

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

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

        stu2.eat("肉");
    }
}

// Output: Pelajar sedang makan daging

3. Ungkapan Lambda untuk melaksanakan multi-threading

Dalam artikel sebelumnya tentang multi-threading (1), kaedahnya. mencipta berbilang benang telah diperkenalkan. Di sini kami menggunakan lambda untuk mencipta benang:

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

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

        t.start();

    }
}

4. Operasi operasi ekspresi Lambda

Kami boleh menggunakan lambda untuk mengendalikan operasi dan menyimpan banyak kod:

Antara muka berfungsi:

@FunctionalInterface
public interface Calculator<T> {

    T operation(T v1,T v2);

}

Kelas ujian:

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);

    }
}

Output:

15, 15, 5

5, Rujukan kaedah ungkapan Lambda

Kadangkala kita tidak perlu menulis semula kaedah antara muka untuk mencapai pelaksanaan tertentu Jika kita mempunyai kaedah sedia ada yang boleh dilaksanakan, kita juga boleh merujuk kepada kaedah sedia ada melalui rujukan kaedah untuk dibuat kaedah dalam antara muka khusus. Kelebihan pelaksanaan ini ialah penggunaan semula kod, seperti berikut:

Antara muka berfungsi:

public interface ResultOneParam {

    int method(int a);
}

Kelas ujian:

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 ungkapan untuk koleksi Menggunakan

, sudah tentu, Lambda juga sangat mudah untuk mengendalikan koleksi, dan anda boleh menyimpan banyak kod:

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);
            }

        });
    }
}

Atas ialah kandungan terperinci Analisis contoh ungkapan Java Lambda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!