Lambda表达式

public class Main {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类写法");
            }
        }).start();
        
        new Thread(() -> System.out.println("Lambda表达式写法")).start();
    }
}

Lambda标准格式,()->{},参数传递,执行方法体,做事情

Lambda省去面向对象的条条框框，格式由3个部分组成：

• 一些参数
• 一个箭头
• 一段代码

Lambda表达式的标准格式为：

(参数类型 参数名称) -> { 代码语句 }

格式说明：

• 小括号内的语法与传统方法参数列表()一致：无参数则留空；多个参数则用逗号分隔。

• ->是新引入的语法格式，代表指向动作,传递

• 大括号内的语法与传统方法体{}要求基本一致

下面举例演示java.util.Comparator<T>接口的使用场景代码，其中的抽象方法定义为：

• public abstract int compare(T o1, T o2);

当需要对一个对象数组进行排序时，Arrays.sort方法需要一个Comparator接口实例来指定排序的规则。假设有一个Person类，含有String name和int age两个成员变量：

public class Person { 
    private String name;
    private int age;
    
    // 省略构造器、toString方法与Getter Setter 
}

传统写法

如果使用传统的代码对Person[]数组进行排序，写法如下：

import java.util.Arrays;
import java.util.Comparator;

public class Demo06Comparator {
    public static void main(String[] args) {
      	// 本来年龄乱序的对象数组
        Person[] array = {
        	new Person("古力娜扎", 19),
        	new Person("迪丽热巴", 18),
       		new Person("马尔扎哈", 20) };

      	//<editor-fold desc="排序写在这里">
       	// TODO: 排序代码
        //</editor-fold>

        for (Person person : array) {
            System.out.println(person);
        }
    }
}

匿名内部类写法

		Arrays.sort(array, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        }); // 第二个参数为排序规则，即Comparator接口实例

Lambda写法

		Arrays.sort(array, (Person o1, Person o2) -> {
            return o1.getAge() - o2.getAge();
        });

优化：

		Arrays.sort(array, (a, b) -> a.getAge() - b.getAge());

再来一个例子

public interface Calculator {
    int calc(int a, int b);
}

public class InvokeCalc {
    public static void main(String[] args) {
        
        // 匿名内部类调用
        invokeCalc(120, 130, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a - b;
            }
        });
        // Lambda【标准格式】调用invokeCalc
        invokeCalc(120, 130, (int a, int b) -> {
            return a + b;
        });

        // 优化
        invokeCalc(120, 130, (a, b) -> a * b);
    }

    private static void invokeCalc(int a, int b, Calculator calculator) {
        int result = calculator.calc(a, b);
        System.out.println("结果是：" + result);
    }
}

打印结果

结果是：-10
结果是：250
结果是：15600

省略规则

在Lambda标准格式()->{}的基础上，使用省略写法的规则为：//记忆

1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参数，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。