Java8新特性：Lambda表达式、函数式接口、方法引用 、 构造器引用 和 数组引用

1、Lambda表达式

Lambda是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。

使用它可以写出更简洁、更灵活的代码。作为一种更紧读的代码风格，使Java的语言表达能力得到了提升。

1.1使用举例

@Test
    public void test02(){

        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        int compare1 = com1.compare(21,32);//-1
        System.out.println(compare1);

        System.out.println("******使用Lambda***********");

        //Lambda表达式
        Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1, o2);
        int compare2 = com2.compare(21,12);//1
        System.out.println(compare2);

        //方法引用

        Comparator<Integer> com3 = Integer :: compare;
        int compare3 = com3.compare(21,12);//1
        System.out.println(compare2);


    }

1.2 Lambda表达式语法

/**
 * @Author 孑然
 *
 * Lambda表达式的使用
 *
 * 1.举例：(o1, o2) -> Integer.compare(o1, o2);
 * 2.格式：
 *      -> : Lambda操作符 或 箭头操作符
 *      ->左边：Lambda形参列表（其实就是接口中的抽象方法的形参列表）
 *      ->右边：Lambda体 （其实就是重写的抽象方法的方法体）
 *
 * 3. Lambda表达式的使用：6种情况
 *
 *
 * 4. Lambda表达式的本质：作为函数式接口的实例
 */

语法格式1：无参， 无返回值

// 语法格式1：无参，无返回值
    @Test
    public void test01(){

        Runnable r1 = new Runnable(){
            @Override
            public void run() {
                System.out.println("你好，我是jack");
            }
        };
        r1.run();
        System.out.println("******使用Lambda***********");

        //使用Lambda表达式
        Runnable r2 = () -> System.out.println("你好，我是张三");
        r2.run();

    }

语法格式2：Lambda需要一个参数，但是没有返回值

//语法格式2：Lambda需要一个参数，但是没有返回值
    @Test
    public void test02(){

        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("世界上最好的语言是什么？");

        //使用Lambda表达式
        Consumer<String> con1 =(String s) -> {
            System.out.println(s);
        };
        con1.accept("是PHP");
    }

语法格式3：数据类型可以省略，因为可由编译器推断，称为类型维护

//语法格式3：数据类型可以省略，因为可由编译器推断，称为类型维护
    @Test
    public void main(){
        //使用Lambda表达式
        Consumer<String> con1 =(s) -> {
            System.out.println(s);
        };
        con1.accept("当然是Java");
    }

语法格式4：Lambda 若只需要一个参数时，参数的小括号可以省略

@Test
    public void test04(){
        Consumer<String> con1 = s -> {
            System.out.println(s);
        };
        con1.accept("当然是Java");
    }

语法格式5：Lambda需要两个或以上的参数，多条执行语句，并且可以有返回值

@Test
    public void test05(){

        Comparator<Integer> comp = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println(o1);
                System.out.println(o2);
                return o1.compareTo(o2);
            }
        };
        //调用
        System.out.println(comp.compare(12, 21));

        //使用Lambda
        Comparator<Integer> comp1 = (o1, o2) -> {
            System.out.println(o1);
            System.out.println(o2);
            return o1.compareTo(o2);
        };
        //调用
        System.out.println(comp1.compare(12, 6));
    }

语法格式6：当 Lambda 体只有一条语句时，return 与 大括号若有，都可以省略

//语法格式6：当 Lambda 体只有一条语句时，return 与 大括号若有，都可以省略
    @Test
    public void test07(){
        //使用Lambda
        Comparator<Integer> comp1 = (o1, o2) -> 
                o1.compareTo(o2);
        
        //调用
        System.out.println(comp1.compare(12, 6));
    }

1.3 Lambda总结

1. -> 左边：
   • Lambda形参列表的参数类型可以省略（类型推断）
   • 如果Lambda形参列表只有一个参数，其一对（）也可以省略
2. -> 右边：
   • 如果Lambda体应该使用一对{}包裹
   • 如果Lambda体只有一条执行语句（可能是return语句），可以省略这一对{}和return关键字；
3. 依赖于函数式接口
4. 以前用匿名实现类表示的现在都可以用Lambda表达式来写

2、函数式接口

基本介绍：

如果一个接口中，之生命了一个抽象方法，则此接口就称为函数式接口

2.1 自定义函数式接口

注意：

注解@FunctionalInterface，是用来校验当前接口是否为函数式接口，同时javadoc也会包含一条声明，说明这个接口是一个函数式接口

与注解override类似

@FunctionalInterface
public interface MyInterface {

    void method1();
}

2.2 Java内置函数式接口

在java.util.function包下定义了java8的丰富的函数式接口

Java内置四大核心函数是接口：

3、方法引用和构造器引用

3.1 方法引用

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

要求：要求接口中的抽象方法的 形参列表和返回值类型 与 方法引用的 形参列表和返回值类型 相同！（针对情况1和2）

方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。

所以方法 也是函数接口的实例

使用格式：类（或对象）:: 方法名

具体分为如下大的三种情况

• 情况1：对象 :: 非静态方法
• 情况2：类 :: 静态方法
• 情况3：类 :: 非静态方法

情况一：对象 :: 实例方法

 //情况一： 对象 :: 实例方法
    //Consumer中的 void accept(T t)
    //PrintDtream中的 void println(T t)
    @Test
    public void test1(){
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");

        //使用方法引用
        Consumer<String> con2 = System.out::println;
        con2.accept("南京");

    }
    //Supplier 中的 T get()
    //Employee 中的String getName()
    @Test
    public void test02(){
        Employee emp = new Employee(1001, "Tom",23, 5600);

        Supplier<String> sup1 = () -> emp.getName();
        System.out.println(sup1.get());

        //使用方法引用
        Supplier<String> sup2 = emp::getName;
        System.out.println(sup2.get());
    }

情况二：类::静态方法

//情况二：类::静态方法
//Comparator中的 int compare(T t1, T t2)
//Integer中的 int compare(T t1, T t2)
@Test
public void test3(){
    Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
    System.out.println(com1.compare(12,21));
    System.out.println("*************");
    //使用方法引用
    Comparator<Integer> com2 = Integer::compare;
    System.out.println(com2.compare(12,6));
 }
//Function 中的 R apply(T t)
//Math 中的 Long round(Double d)
@Test
public void test4(){
    Function<Double,Long> function1 = d -> Math.round(d);
    System.out.println(function1.apply(1.85));//2

    //使用方法引用
    Function<Double,Long> function2 = Math::round;
    System.out.println(function2.apply(1.25));//1
}

情况三：类 :: 实例方法

//情况三：类 :: 实例方法
    //Comparator 中的int compare(T t1, T t2)
    //String 中的 int t1.compareTo(t2)
    @Test
    public void test5(){
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));

        //使用方法引用
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("bcd", "bca"));
    }
    //BiPredicate 中的 boolean test(T t1, T t2)
    //String 中的 boolean t1.equals(t2)
    @Test
    public void test6(){
        BiPredicate<String,String> pre1 = (s, s2) -> s.equals(s2);
        System.out.println(pre1.test("abc", "abc"));

        //使用方法引用
        BiPredicate<String,String> pre2 = String::equals;//true
        System.out.println(pre2.test("acd", "acd"));//true
    }

3.2 构造器引用

构造器引用

•  和方法引用类似，函数式接口的 抽象方法的形参列表 和 构造器的 形参列表一致。
  

•  抽象方法的返回值类型 即为 构造器 所属的类的类型
  

//无参
    //构造器引用
    //Supplier 中的 T get()
    @Test
    public void test1(){

        Supplier<Employee> sup1 = () -> new Employee();
        Employee employee = sup1.get();
        //使用构造器引用
        Supplier<Employee> sup2 = Employee::new;
        Employee employee1 = sup2.get();
    }
    //有参
    //Function 中的 R apply(T t)
    @Test
    public void test2(){
        Function<Integer, Employee> fun1 = id -> new Employee(id);
        Employee employee = fun1.apply(1002);
        System.out.println(employee);

        //使用构造器引用
        Function<Integer, Employee> fun2 = Employee::new;
        Employee employee1 = fun2.apply(1003);
        System.out.println(employee1);
    }
    //有参
    //BiFunction 中的 R apply(T t, U u)
    @Test
    public void test3(){
        BiFunction<Integer,String,Employee> func1 = (id, name) -> new Employee(id,name);
        Employee employee = func1.apply(1004, "Tom");
        System.out.println(employee);

        //使用构造器引用
        BiFunction<Integer,String,Employee> func2 = Employee::new;
        Employee employee1 = func2.apply(1005, "jack");
        System.out.println(employee1);
    }

3.3 数组引用

跟构造器引用类似

//数组引用
    //Function 中的 R apply(T t)
    @Test
    public void test4(){

        Function<Integer, String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(8);
        System.out.println(Arrays.toString(arr1));

        //使用数组引用
        Function<Integer, String[]> func2 = String[]::new;
        String[] arr2 = func2.apply(8);
        System.out.println(Arrays.toString(arr2));
        
    }