方法的引用与构造器引用

什么是方法的引用：

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就 是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向 一个方法，可以认为是Lambda表达式的一个语法糖

什么时候使用方法的引用

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

使用要求

要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的 方法的参数列表和返回值类型保持一致！

方法引用的格式

格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。 

如下三种主要使用情况： 
     对象::实例方法名 
     类::静态方法名 
     类::实例方法名

// 情况一：对象 :: 实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)
    @Test
    public void TestJanuary(){
        Consumer<String> con = str-> System.out.println(str);
        con.accept("老王");

        PrintStream  ps = System.out;
        Consumer<String> con1 = ps::print;
        con1.accept("老张");
    }

    //Supplier中的T get()
    //Employee中的String getName()
    @Test
    public void TestMonday(){
        Employee epm = new Employee(1001,"老王",30,800);
        Supplier<String> sup = () -> epm.getName();
        System.out.println(sup.get());

        System.out.println("====方法的引用=====");
        Supplier<String> sip1 = epm::getName;
        System.out.println(sip1.get());
    }


    // 情况二：类 :: 静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)

    @Test
    public void TestFebruary(){
        Comparator<Integer> com = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com.compare(1, 2));

        Comparator<Integer> com1 = Integer::compareTo;  // 后面的其实就是方法体
        System.out.println(com1.compare(3, 1));
    }

    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void TestTuesday(){
        Function<Double,Long>func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };


        System.out.println("====lambda====");

        Function<Double,Long>funcMonday = d -> Math.round(d);
        System.out.println(funcMonday.apply(12.3));

        Function<Double,Long> funcTuesday = Math::round;
        System.out.println(funcTuesday.apply(24.6));
    }


    // 情况三：类 :: 实例方法  (有难度)
    // Comparator中的int compareTo(T t1,T t2)
    // String中的int t1.compareTo(t2)

    @Test
    public void TestMarch(){
        Comparator<String> com = (s,k) -> s.compareTo(k);
        System.out.println(com.compare("aa","bb"));

        Comparator<String>com1 = String::compareTo;
        System.out.println(com1.compare("AA", "BB"));
    }

    //BiPredicate中的boolean test(T t1, T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void TestApril(){
        BiPredicate<String,String> pre = (s1, s2) -> s1.contains(s2);
        System.out.println(pre.test("laowang", "lao"));

        BiPredicate<String,String> preApril = String::contains;
        System.out.println(preApril.test("老王", "王"));
    }

    // Function中的R apply(T t)
    // Employee中的String getName();
    @Test
    public void TestMay(){
        Employee employee = new Employee(1002,"隔壁老王",23,800.2);
        Function<Employee,String> emp = e -> employee.getName();
        System.out.println(emp.apply(employee));

        Function<Employee,String> empMay = Employee::getName;
        System.out.println(empMay.apply(employee));
    }

构造器引用

格式： ClassName::new 

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

数组引用

格式： type[] :: new

//构造器引用
    //Supplier中的T get()
    //Employee的空参构造器：Employee()
    @Test
    public void TestJanuary(){
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };

        System.out.println("====lambda=====");
        Supplier<Employee> supplier = () -> new Employee();
        System.out.println(supplier.get());

        System.out.println("******************");
        Supplier<Employee>supJanuary = Employee::new;
        System.out.println(supJanuary.get());
    }


    //Function中的R apply(T t)
    @Test
    public void TestFebruary(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);

        Function<Integer,Employee> func2 = Employee::new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);
    }

    //数组引用
    //Function中的R apply(T t)
    @Test
    public void TestMarch(){
        Function<Integer,String[]> func1 = length -> new String[length];
        String [] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));


        System.out.println("*******************");

        Function<Integer,String []> func2 = String[] ::new;
        String [] arr2 = func2.apply(5);
        System.out.println(Arrays.toString(arr2));
    }

.