Java 中Lambda表达式的使用详解

Posted 2022-02-06 路宇

前言：

通过创建子线程的例子，来进行分析学习。

public class LambdaDemo 
    public static void main(String[] args) 
//        Thread thread = new Thread(new MyRunnable());
//        thread.start();

        //匿名内部类的方式改进
//        new Thread(new Runnable() 
//            @Override
//            public void run() 
//                System.out.println("多线程启动");
//            
//        ).start();

        //Lambda表达式
        new Thread(()->
            System.out.println("多线程启动");
        ).start();
    

1.分析匿名内部类重写run()方法的代码

1. 方法形式参数为空，说明调用方法时，不需要传递参数
2. 方法返回值类型为void，说明方法执行没有结果返回
3. 方法体中的内容，是我们要做的事情

2.Lambda表达式的代码分析

1. () ：里面没有内容，可以看成是方法形式参数为空
2. ->：用箭头指向后面要做的事情
3. ：包含一段代码，我们称之为代码块，可以看成是方法体中的内容

总结：组成Lambda表达式的三要素：形式参数，箭头，代码块

正文：

Lambda表达式的格式：

1. 格式：(形式参数)->代码块
2. 形式参数：如果有多个参数，参数之间用逗号隔开，如果没有参数，留空即可
3. ->:由英文中画线和大于符号组成，固定写法。代表指向动作
4. 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

一、使用Lambda表达式练习1

/**
 * 1.定义一个接口(Eatable),里面定义了一个抽象方法：void eat()
 * 2.定义一个测试类(EatableDemo),在测试类中提供了两个方法，一个方法是useEatable(Eatable)
 * 一个是主方法，在主方法中调用useEatable()方法
 */
public class EatableDemo 
    public static void main(String[] args) 
        //EatableImple是Eatable接口的实现类，重写了eat()方法
//        useEatable(new EatableImple());
        //使用匿名内部类
        useEatable(new Eatable() 
            @Override
            public void eat() 
                System.out.println("hello,world!");
            
        );

        //使用Lambda表达式
        useEatable(() -> 
            System.out.println("hello,world!");
        );
    

    private static void useEatable(Eatable eatable) 
        eatable.eat();
    

输出结果：

hello,world!
hello,world!

二、使用Lambda表达式练习2

/**
 * 1.定义一个接口(Flyable),里面定义了一个抽象方法：void fly(String s);
 * 2.定义一个测试类(FlyableDemo),在测试类中提供了两个方法，
 * 一个方法是fly(Flyable flyable)
 * 一个是主方法，在主方法中调用fly()方法
 */
public class FlyableDemo 
    public static void main(String[] args) 
        //使用匿名内部类
        fly(new Flyable() 
            @Override
            public void fly(String s) 
                System.out.println(s);
            
        );
        System.out.println("----------");
        //使用Lambda表达式
        fly((String s) -> 
            System.out.println(s);
        );
    

    private static void fly(Flyable flyable) 
        flyable.fly("Java语言");
    

输出结果：

Java语言
----------
Java语言

三、使用Lambda表达式练习3

/**
 * 1.定义一个接口(Addable),里面定义了一个抽象方法：int add(int x,int y);
 * 2.定义一个测试类(AddableDemo),在测试类中提供了两个方法，
 * 一个方法是：useAddable(Addable a)
 * 一个是主方法，在主方法中调用useAddable方法
 */
public class AddableDemo 
    public static void main(String[] args) 
        //使用匿名内部类实现
        useAddable(new Addable() 
            @Override
            public int add(int x, int y) 
                return x + y;
            
        );

        //使用Lambda表达式
        useAddable((int x, int y) -> 
            return x + y;
        );
    

    private static void useAddable(Addable a) 
        int sum = a.add(2, 6);
        System.out.println(sum);
    

输出结果：

8
8

四、Lambda表达式的省略模式

省略规则：

1. 参数类型可以省略。但是有多个参数的情况下，不能只省略一个。
2. 如果参数有且仅有一个，那么小括号可以省略。
3. 如果代码块的语句只有一条，则可以省略大括号和分号，甚至是return。

演示如下：

public class LambdaDemo 
    public static void main(String[] args) 


//        useAddable((int x, int y) -> 
//            return x + y;
//        );
        //参数的类型可以省略
        useAddable((x, y) -> 
            return x + y;
        );
        //但有多个参数的情况下,不能只省略一个,编译不通过
//        useAddable((x, int y) -> 
//            return x + y;
//        );
//        useFlyable((String s)->
//            System.out.println(s);
//        );

//        useFlyable(s -> 
//            System.out.println(s);
//        );
        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号。如果有return,return也要省略掉
        useAddable((x, y) -> x + y);

    

    private static void useFlyable(Flyable flyable) 
        flyable.fly("风和日丽,晴空万里");
    

    private static void useAddable(Addable addable) 
        int add = addable.add(10, 20);
        System.out.println(add);
    

五、Lambda表达式的省略模式

注意事项：

1. 使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法。
2. 必须有上下文环境，才能推导出Lambda对应的接口
   根据局部变量的赋值得知Lambda对应的接口：Runnable r = () -> System.out.println(“匿名内部类”);
   根据调用方法的参数得知Lambda对应的接口：new Thread(() -> System.out.println(“Lambda表达式”)).start();

演示代码如下：

public class IterDemo 
    public static void main(String[] args) 
        useInter(() -> 
            System.out.println("好好学习，天天向上！");
        );

        //使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法
        useInter(() -> System.out.println("好好学习，天天向上！"));

        //必须有上下文环境，才能推导出Lambda对应的接口
        new Thread(new Runnable() 
            @Override
            public void run() 
                System.out.println("匿名内部类");
            
        ).start();

        Runnable r = () -> System.out.println("Lambda表达式");
        new Thread(r).start();

        new Thread(() -> System.out.println("Lambda表达式")).start();
    

    private static void useInter(Inter inter) 
        inter.show();
    

输出结果：

好好学习，天天向上！
好好学习，天天向上！
匿名内部类
Lambda表达式
Lambda表达式

六、Lambda表达式和匿名内部类的区别

代码演示：
1、创建一个接口名为：Inter

public interface Inter 
    void show();
//    void show2();

2、创建一个抽象类：Animal

public abstract class Animal 
    public abstract void method();

3、创建一个具体类：Student

public class Student 
    public void study()
        System.out.println("爱生活，爱java");
    

4、创建一个测试类：Lambda

public class Lambda 
    public static void main(String[] args) 
        //匿名内部类
        useInter(new Inter() 
            @Override
            public void show() 
                System.out.println("接口");
            
        );
//
//        useAnimal(new Animal() 
//            @Override
//            public void method() 
//                System.out.println("抽象类 ");
//            
//        );
//
//        useStudent(new Student() 
//            @Override
//            public void study() 
//                System.out.println("爱学习！");
//            
//        );

        //使用Lambda表达式
//        useInter(()-> System.out.println("接口"));
		//下面这两个编译错误，使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法。
//       useAnimal(()->
//           System.out.println("抽象类");
//       );
//        useStudent(()-> System.out.println("具体类"));

//        useInter(new Inter() 
//            @Override
//            public void show() 
//                System.out.println("show");
//            
//
//            @Override
//            public void show2() 
//                System.out.println("show2");
//            
//        );
    

    private static void useStudent(Student s) 
        s.study();
    

    private static void useInter(Inter inter) 
        inter.show();
    

    private static void useAnimal(Animal animal) 
        animal.method();
    

具体区别：