lambda 表达式三要素：形式参数，箭头，代码块

1、Lambda 表达式的标准格式

格式：

( 形式参数 ) -> { 代码块 }

1
2
3
4
new Thread(() -> {
    System.out.println("多线程启动了！");
}
).start();
  • 形式参数：如果有多个参数，参数之间用逗号隔开。如果没有参数，留空即可
  • ->：固定写法
  • 代码块：具体要做的内容

2、Lambda 表达式注意事项

  • 有一个接口，并且接口中有且仅有一个抽象方法
  • 必须要有上下文环境，才能推导出 Lambda 对应的接口（也就是说Lambda表达式不能单独使用）

3、Lambda 表达式实例

3.1 既没有参数也没有返回值的情况

1
2
3
4
5
6
7
8
9
10
11
12
13
public class lambda01 {
    public static void main(String[] args) {
        myPrint(() -> {
            System.out.println("既没有参数，也没有返回值");
        });
    }

    private static void myPrint(Print a) { a.UserPrint(); }
}

interface Print {
    void UserPrint();
}

3.2 有参数，无返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
public class lambda02 {
    public static void main(String[] args) {
        myFly((String s) -> {
            System.out.println(s);
        });
    }

    private static void myFly(Fly cat) { cat.AnimalFly("The cat is flying!"); }
}

interface Fly {
    void AnimalFly(String s);
}

3.3 有参数，有返回值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Lambda03 {
    public static void main(String[] args) {
        MyOperate((int a, int b) -> {
            return a + b;
        });
    }

    private static void MyOperate(Operate operate) {
        int sum = operate.UserOperate(1, 1);
        System.out.println(sum);
    }
}

interface Operate {
    int UserOperate(int a, int b);
}

4. Lambda 表达式的省略模式

省略规则：

  1. 参数类型可以省略，但是又多个参数的情况下，不能只省略一个
  2. 如果参数有且仅有一个，那么小括号可以省略
  3. 如果代码块的语句只有一条，那么可以省略大括号和分号
  4. 如果代码块的语句只有一条，并且这条语句是 return 语句，那么可以省略大括号和分号和return
1
2
3
4
5
MyOperate((int a, int b) -> {
    return a + b;
});
//============================
MyOperate((a, b) -> a + b);

5. Lambda 表达式和匿名内部类的区别

  1. 所需类型不同
    • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
    • Lambda表达式：只能是接口
  2. 使用限制不同
    • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
    • 如果接口中有多于一个的抽象方法，则只能使用匿名内部类
  3. 实现原理不同
    • 匿名内部类：编译之后，产生一个单独的.class 字节码文件
    • Lambda 表达式：编译之后，没有一个单独的.class 字节码文件，对应的字节码会在运行的时候动态生成