Bagaimana untuk menggunakan ungkapan Lambda dalam Java?

Pengenalan ungkapan Lambda

• Intipati ungkapan Lambda hanyalah "gula sintaks", yang disimpulkan oleh pengkompil dan membantu anda menukar dan membungkusnya ke dalam kod biasa, jadi anda boleh menggunakan kurang kod untuk mencapai fungsi yang sama.

• Ekspresi Lambda ialah ciri baharu yang penting dalam Java SE 8.

Lambda dan kelas dalaman tanpa nama

Ungkapan Lamda merujuk kepada aplikasi dalam persekitaran SAM (SingleAbstractMethod, antara muka yang mengandungi kaedah abstrak) Satu bentuk yang dipermudahkan takrifan.

Kelebihan Lambda berbanding kelas dalaman tanpa nama

Mudah (lihat "Antara Muka Fungsian" di bawah untuk butiran)

Lamda berbanding kelas dalaman tanpa nama Kelemahan kelas

• Antara muka yang sepadan dengan Lamda hanya boleh mempunyai satu kaedah.

• Antara muka yang sepadan dengan kelas dalaman tanpa nama boleh mempunyai pelbagai kaedah

Keperluan untuk antara muka

1.Lambda menetapkan bahawa hanya ada satu kaedah yang perlu dilaksanakan dalam antara muka (iaitu, kaedah abstrak).

Dalam antara muka, yang berikut boleh wujud pada masa yang sama: satu kaedah abstrak (hanya boleh ada satu), berbilang kaedah lalai dan berbilang kaedah statik.

// Terdapat satu lagi ciri baharu dalam jdk 8: lalai Kaedah yang diubah suai secara lalai akan mempunyai pelaksanaan lalai dan bukan kaedah yang mesti dilaksanakan, jadi ia tidak menjejaskan penggunaan ungkapan Lambda.

2.@FunctionalInterface: Digunakan untuk mengubah suai antara muka berfungsi.

@FunctionalInterface boleh ditulis atau tidak. Anotasi ini digunakan terutamanya untuk semakan ralat peringkat penyusunan: apabila antara muka tidak mematuhi definisi antara muka berfungsi, pengkompil akan melaporkan ralat.

Contoh yang betul, tiada ralat dilaporkan:

@FunctionalInterface
public interface HelloWorldService {
    void sayHello(String msg);
}

Contoh salah, ralat dilaporkan:

Antara muka mengandungi dua kaedah abstrak, yang melanggar takrifan antara muka berfungsi , segera Berbilang kaedah abstrak tidak ditindih ditemui dalam antara muka.

Nota: Menambah atau tidak menambah @FunctionalInterface tidak mempunyai kesan sama ada antara muka ialah antara muka berfungsi ini hanya mengingatkan pengkompil untuk menyemak sama ada antara muka hanya mengandungi satu abstrak kaedah.

Pembolehubah dan Skop

• Ekspresi Lambda hanya boleh merujuk pembolehubah tempatan luar yang ditanda muktamad. Iaitu, pembolehubah tempatan yang ditakrifkan di luar skop tidak boleh diubah suai di dalam lambda, jika tidak, ralat kompilasi akan dilaporkan

• Pembolehubah tempatan ungkapan Lambda tidak perlu diisytiharkan muktamad, tetapi ia tidak boleh diubah suai oleh kod berikutnya (iaitu. Secara tersirat dengan semantik akhir)

• Ungkapan Lambda tidak dibenarkan untuk mengisytiharkan parameter atau pembolehubah tempatan dengan nama yang sama dengan pembolehubah tempatan.

Format

Ciri penting ungkapan lambda

• Pengisytiharan jenis pilihan: tidak perlu mengisytiharkan jenis parameter, nilai Parameter pengkompil boleh dikenal pasti secara seragam.

• Kurungan parameter pilihan: Tidak perlu mentakrifkan kurungan untuk parameter, tetapi berbilang parameter perlu mentakrifkan kurungan.

• Pendakap gigi pilihan: Jika badan mengandungi pernyataan, pendakap tidak diperlukan. Contoh: () -> Sysout.out.println("Test");

• Kata kunci pulangan pilihan: Jika badan hanya mempunyai satu nilai pulangan ungkapan, pengkompil akan Mengembalikan nilai secara automatik , pendakap kerinting perlu dinyatakan untuk menunjukkan bahawa ungkapan itu mengembalikan nilai.

Contoh ringkas ungkapan Lambda

1 Tiada parameter diperlukan, nilai pulangan ialah 5

() -> >

2. Terima satu parameter (jenis nombor) dan kembalikan 2 kali ganda nilainya

x -> 2 * x

3 perbezaan

(x, y) -> int y) -> System.out.print(s)

Format sintaks

Format:

Sebelah kiri: senarai parameter ungkapan Lambda

Sebelah kanan: fungsi yang akan dilaksanakan dalam ungkapan Lambda (badan Lambda)

Format sintaks satu: tiada parameter , tiada nilai pulangan

(parameters) -> statement   或(parameters) ->{ statements; }

Format tatabahasa 2 : Terdapat satu parameter dan tiada nilai pulangan

() -> Sysout.out.println("Test");

Format tatabahasa tiga: Jika terdapat satu kurungan parameter, anda tidak perlu menulis

(X)-> Sysout.out.println(x);

Format tatabahasa empat: Terdapat lebih daripada dua Parameter, nilai pulangan dan terdapat berbilang pernyataan dalam badan Lambda Anda perlu menggunakan {}

dalam badan sintaks format 5: Hanya gunakan satu pernyataan dalam kandungan Lambda, kembali dan {} boleh ditinggalkan dan jangan tulis X-> Sysout.out.println(x);

.

语法格式六：表达式的参数列表的数据类型可以省略不写，JVM编译器通过上下文推断出数据类型

(x ,y ) ->Integer.compare(x ,y)

实例

无参数无返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    void run();
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class: ");
            }
        };
 
        Interface params1 = () -> System.out.println("Lambda: ");
 
        params.run();
        params1.run();
    }
}

执行结果

Anonymous Internal Class: 
Lambda: 

有参数无返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    void run(String s);
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public void run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
            }
        };
 
        Interface params1 = (s) -> System.out.println("Lambda: " + s);
 
        params.run("hello");
        params1.run("hi");
    }
}

执行结果

Anonymous Internal Class: hello
Lambda: hi 

有参数有返回值

package org.example.a;
 
@FunctionalInterface
interface Interface {
    String run(String s);
}
 
public class Demo{
    public static void main(String[] args) {
        Interface params = new Interface() {
            @Override
            public String run(String s) {
                System.out.println("Anonymous Internal Class: " + s);
                return "abc";
            }
        };
 
        Interface params1 = (s) -> {
            System.out.println("Lambda: " + s);
            return "def";
        };
 
        System.out.println(params.run("hello"));
        System.out.println(params1.run("hi"));
    }
}

执行结果

Anonymous Internal Class: hello
abc
Lambda: hi
def 

lambda作为参数

传递一个函数

package org.example.a;
 
interface IRun {
    String welcome(String string);
}
 
class Util {
    public static long executionTime1(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时，防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
 
    public long executionTime2(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时，防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
 
    public static String hello(String string){
        String tmp;
        tmp = "hello: " + string;
        return tmp;
    }
 
    public String hi(String string){
        String tmp;
        tmp = "hi: " + string;
        return tmp;
    }
}
 
public class Demo {
    public static void main(String[] args) {
        long time1 = Util.executionTime1(Util::hello, "Tony");
        long time2 = new Util().executionTime2(new Util()::hi, "Pepper");
        System.out.println("time1: " + time1 + "ms");
        System.out.println("time2: " + time2 + "ms");
    }
}

执行结果

hello: Tony
hi: Pepper
time1: 11ms
time2: 11ms

直接传递lambda函数 

package org.example.a;
 
interface IRun {
    String welcome(String string);
}
 
class Util {
    public static long executionTime(IRun iRun, String string) {
        long startTime = System.currentTimeMillis();
        System.out.println(iRun.welcome(string));
        //本处刻意添加这一无意义延时，防止执行太快返回0
        try {
            Thread.sleep(10);
        } catch (Exception e) {
            System.out.println(e);
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }
}
 
public class Demo {
    public static void main(String[] args) {
        long time = Util.executionTime((string -> {
                    String tmp;
                    tmp = "hello: " + string;
                    return tmp;
                })
                , "Tony");
        System.out.println("time: " + time + "ms");
    }
}

执行结果

hello: Tony
time: 11ms

遍历集合

package org.example.a;
 
import java.util.ArrayList;
import java.util.List;
 
public class Demo{
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
 
        //以前的循环方式
        for (String string : list) {
            System.out.println(string);
        }
 
        //使用lambda表达式输出list中的每个值
        list.forEach(c->{
            System.out.println(c);
        });
 
        // 在 Java 8 中使用双冒号操作符(double colon operator）。也属于lamda表达式
        list.forEach(System.out::println);
    }
}

执行结果

aaa
bbb
aaa
bbb
aaa
bbb

创建线程

package org.example.a;
 
public class Demo{
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("Anonymous Internal Class !");
            }
        }).start();
 
        new Thread(() -> System.out.println("Lambda !")).start();
    }
}

执行结果

Anonymous Internal Class !
Lambda !

排序

package org.example.a;
 
import java.util.Arrays;
import java.util.Comparator;
 
public class Demo{
    public static void main(String[] args) {
        String[] players = {"Rafael Nadal", "Novak Djokovic", "Stanislas Wawrinka"};
        
        Arrays.sort(players, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return (o1.compareTo(o2));
            }
        });
 
//        Comparator<String> sortByName = (String s1, String s2) -> (s1.compareTo(s2));
//        Arrays.sort(players, sortByName);
        
//        Arrays.sort(players, (String s1, String s2) -> (s1.compareTo(s2)));
        
        for(String string:players){
            System.out.println(string);
        }
    }
}

执行结果（换成注释掉的两种任意一种都是一样的）

Novak Djokovic
Rafael Nadal
Stanislas Wawrinka

Atas ialah kandungan terperinci Bagaimana untuk menggunakan ungkapan Lambda dalam Java?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!