方法引用与构造器引用

一、方法引用

1、什么是方法引用

当要传递给Lambda体的操作，已经有实现的方法，可以使用方法引用。（实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致）

（可以将方法引用理解为 Lambda 表达式的另外一种表现形式）

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

如下三种主要使用情况：

1. 对象的引用 :: 实例方法名

2. 类名 :: 静态方法名

3. 类名 :: 实例方法名

   注意：

   ①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！

   ②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

2、方法引用举例

（1）、对象的引用 :: 实例方法名

// 1. 对象的引用 :: 实例方法名
    @Test
    public void test() {
        // ①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("hello");

        PrintStream ps = System.out;
        Consumer<String> con2 = (x) -> ps.println(x);
        con2.accept("hello");

        // 对象的引用 :: 实例方法名
        PrintStream ps2 = System.out;
        Consumer<String> con3 = ps2::println;
        con3.accept("hello");

    }

    @Test
    public void test2() {
        Employee emp = new Employee();

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

        // 对象的引用 :: 实例方法名
        Supplier<Integer> sup2 = emp::getAge;
        Integer num = sup2.get();
        System.out.println(num);
    }

（2）、类名 :: 静态方法名

// 2. 类名 :: 静态方法名
    @Test
    public void test3() {

        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
        // int compare = com.compare(2, 3);
        // System.out.println(compare);

        // 类名 :: 静态方法名
        Comparator<Integer> com2 = Integer::compare;
    }

（3）、类名 :: 实例方法名

// 3. 类名 :: 实例方法名
    @Test
    public void test4() {
        BiPredicate<String, String> bp = (x, y) -> x.equals(y);
        // 使用要求： 若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式：
        // ClassName::MethodName
        BiPredicate<String, String> bp2 = String::equals;
        // boolean test = bp2.test("hello", "hello");
        // System.out.println(test);
    }
    
        
    }

二、构造器引用

1、什么是构造器引用

格式:ClassName::new

与函数式接口相结合，自动与函数式接口中方法兼容。可以把构造器引用赋值给定义的方法，与构造器参数列表要与接口中抽象方法的参数列表一致！

2、构造器引用的例子

    
    //二、构造器引用 :构造器的参数列表，需要与函数式接口中参数列表保持一致！
     //1. 类名 :: new
    //ClassName::new
    //注意：需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致、
    @Test
    public void test5() {
        Supplier<Employee> sup =()->new Employee();
        
        //构造器引用方式
        Supplier<Employee> sup2=Employee::new;
        Employee emp=sup2.get();
        System.out.println(emp);
    }
    @Test
    public void test6() {
        Function<Integer,Employee> fun=(x)->new Employee(x);
        
        Function<Integer,Employee> fun2=Employee::new;
        Employee emp=fun2.apply(101);
        System.out.println(emp);
        //需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致、
        //这里的参数列表，就对应employee的构造器的列表一样
        BiFunction<Integer,Integer,Employee> bif=Employee::new;
        Employee apply = bif.apply(2, 3);
        System.out.println(apply);
        
    }

三、数组引用

1、数组引用格式

格式：type[]::new

2、数组引用例子

//数组引用
    //三、数组引用
    //类型[] :: new;
    @Test
    public void test7() {
        Function<Integer,String[]> fun=(x)->new String[x];
        String[] apply = fun.apply(10);
        System.out.println(apply.length);
        
        
        Function<Integer,String[]> fun2=String[]::new;
        String[] apply2 = fun2.apply(10);
        System.out.println(apply2.length);
    }