一、Lambda 表达式

Lambda 是一个 匿名函数 ，我们可以把 Lambda表达式理解为是 一段可以传递的代码 （将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

案例：从匿名内部类---》Lambda表达式

（一）Lambda 表达式语法

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “ -> ” ， 该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的所有参数

右侧：指定了 Lambda 体，即 Lambda 表达式要执行的功能。

（二）类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “类型推断“

二、函数式接口

只包含一个抽象方法的接口，称为 函数式接口 。

你可以通过 Lambda 表达式来创建该接口的对象。（若 Lambda表达式抛出一个受检异常，那么该异常需要在目标接口的抽象方法上进行声明）。

我们可以在任意函数式接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口，同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

（三）Java 内置四大核心函数式接口

相关代码演示：

/*
 * @Description Java8 内置四大核心函数式接口
 * Consumer<T> : 消费型接口
 *      void accept(T t)
 *
 * Supplier<T> : 供给型接口
 *      T get();
 *
 * Function<T, R> : 函数型接口
 *      R apply(T t)
 *
 * Predicate<T> : 断言型接口
 *      boolean test(T t)
 **/
public class TestLambda02 {
 
    /*
     * Predicate<T> : 断言型接口
     * 将长度大于等于3的字符串输出
     */
 
    @Test
    public void test04() {
        List<String> stringList = Arrays.asList("hello", "world","you");
        List<String> list = getStringList(stringList, (s) -> s.length() > 3);
        list.forEach(System.out::println);
    }
    public List<String> getStringList(List<String> stringList, Predicate<String> pre) {
        List<String> strings = new ArrayList<>();
        for (String s : stringList) {
            if(pre.test(s)) {
                strings.add(s);
            }
        }
        return strings;
    }
    /*
     * Function<T, R> : 函数型接口
     *
     */
    @Test
    public void test03() {
        String string = getString("\t\t\t 帅哥好帅", (str) -> str.trim());
        System.out.println(string);
    }
    public String getString(String str, Function<String ,String> func) {
        return func.apply(str);
    }
 
    /*
     * Supplier<T> : 供给型接口
     * 随机产生10个数字
     */
    @Test
    public void test02() {
        int num = 10;
        generator(num, () -> (int)(Math.random() * 100) + 1);
    }
    public void generator(int x, Supplier<Integer> sup) {
        List<Integer> integerList = new ArrayList<>();
        for(int i = 0; i < x; i ++) {
            Integer integer = sup.get();
            integerList.add(integer);
        }
        integerList.forEach(System.out::println);
    }
 
    /*
     * Consumer<T> : 消费型接口
     */
    @Test
    public void test01() {
        int num = 100;
        consumer(num, x -> System.out.println("消费了" + num + "元"));
    }
    public void consumer(int num, Consumer<Integer> com) {
        com.accept(num);
    }
}

三、方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

（ 实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！ ）

方法引用：使用操作符 “ :: ” 将方法名和对象或类的名字分隔开来。

如下三种主要使用情况 ：

• 对象::实例方法
• 类::静态方法
• 类::实例方法

/*
 * 一、方法引用： 若Lambda体中的内容有方法已经实现了，我们可以通过方法引用
 *                  （即方法引用是Lambda表达式的另外一种表现形式）
 * 主要有三种语法格式：
 *
 * 对象::实例方法名
 * 类::静态方法名
 * 类::实例方法名
 *
 * 注意：Lambda体中调用方法的参数列表与返回值类型，要与函数式接口中抽象方法的参数列表和返回值类型一致
 *
 * 二、构造器引用
 * 格式： ClassName::New
 *
 * 注意：需要调用的构造器的参数列表要与函数式接口中的抽象方法的参数列表一致！
 *
 * 三、数组引用
 * 格式：Type[]::new
 */
public class TestMethodRef {
    // 数组引用
    @Test
    public void test05() {
        Function<Integer, String[]> func = (x) -> new String[x];
        String[] strings = func.apply(10);
        System.out.println(strings.length);
 
        Function<Integer, String[]> func2 = String[]::new;
        String[] strs = func2.apply(20);
        System.out.println(strs.length);
 
    }
 
    // 构造器引用
    @Test
    public void test04() {
        Supplier<Employee> sup = () -> new Employee();
        // 构造器引用的方式
        Supplier<Employee> sup2 = Employee::new;
        Employee employee = sup2.get();
        System.out.println(employee);
        /*
         * 如何知道调用的是哪一个构造方法?
         * 根据函数式接口传入的参数的个数决定调用的构造器方法
         */
        Function<Integer, Employee> func = Employee::new;
        Employee employee1 = func.apply(20);
        System.out.println(employee1);
 
    }
 
    // 类::实例方法名
    @Test
    public void tes03() {
        // 规则：若Lambda参数列表中的第一参数是实例方法的调用者，第二参数是实例方法的参数时，此时
        //      可以通过 class::method
        BiPredicate<String ,String> bp = (x, y) -> x.equals(y);
 
        BiPredicate<String ,String> bp1 = String::equals;
    }
 
    // 对象::静态方法
    @Test
    public void  test02() {
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
        Comparator<Integer> com1 = Integer::compare;
 
    }
 
    // 对象::实例方法
    @Test
    public void test01() {
        PrintStream ps = System.out;
        Consumer<String> con = (x) -> System.out.println(x);
        Consumer<String> con2 = ps::println;
    }
}