方法引用：

1. 使用情境：當(dāng)要傳遞給Lambda體的操作，已經(jīng)有實(shí)現(xiàn)的方法了，可以使用方法引用！
2. 方法引用，本質(zhì)上就是Lambda表達(dá)式，而Lambda表達(dá)式作為函數(shù)式接口的實(shí)例。所以方法引用，也是函數(shù)式接口的實(shí)例。
3. 具體分為如下的三種情況：
   情況1 對(duì)象 :: 非靜態(tài)方法
   情況2 類(對(duì)象) :: 靜態(tài)方法
   情況3 類 :: 非靜態(tài)方法
4. 方法引用使用的要求：要求接口中的抽象方法的形參列表和返回值類型與方法引用的方法的形參列表和返回值類型相同！（針對(duì)于情況1和情況2）

• 情況一：對(duì)象 :: 實(shí)例方法

//Consumer中的void accept(T t)
        // Lambda寫法
        Consumer<String> con1 = str -> System.out.println(str);

        // 方法引用寫法
        //Consumer中的void accept(T t)
        //PrintStream中的void println(T t)
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;

        Employee emp = new Employee(1001,"Tom",23,5600);

        // Lambda寫法
        Supplier<String> sup1 = () -> emp.getName();

        //Supplier中的T get()
        //Employee中的String getName()
        // 方法引用寫法
        Supplier<String> sup2 = emp::getName;

• 情況二：類(對(duì)象) :: 靜態(tài)方法

        //Comparator中的int compare(T t1,T t2)
        //Integer中的int compare(T t1,T t2)
        // 方法引用寫法
        Comparator<Integer> com2 = Integer::compare;

        // 原始寫法
        Function<Double, Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };

        // Lambda寫法
        Function<Double, Long> func1 = d -> Math.round(d);

        //Function中的R apply(T t)
        //Math中的Long round(Double d)
        // 方法引用寫法
        Function<Double, Long> func2 = Math::round;

• 情況三：類 :: 實(shí)例方法

        // Lambda寫法
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);

        // Comparator中的int comapre(T t1,T t2)
        // String中的int t1.compareTo(t2)
        // 方法引用寫法
        Comparator<String> com2 = String::compareTo;

        // Lambda寫法
        BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);

        //BiPredicate中的boolean test(T t1, T t2);
        //String中的boolean t1.equals(t2)
        // 方法引用寫法
        BiPredicate<String, String> pre2 = String::equals;

        Employee employee = new Employee(1001, "Jerry", 23, 6000);

        // Lambda寫法
        Function<Employee, String> func1 = e -> e.getName();

        // Function中的R apply(T t)
        // Employee中的String getName();
        // 方法引用寫法
        Function<Employee, String> func2 = Employee::getName;

構(gòu)造器引用：

1. 和方法引用類似，函數(shù)式接口的抽象方法的形參列表和構(gòu)造器的形參列表一致。
2. 抽象方法的返回值類型即為構(gòu)造器所屬的類的類型

        //原始寫法
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };

        // Lambda寫法
        Supplier<Employee>  sup1 = () -> new Employee();

        //構(gòu)造器引用寫法
        //Supplier中的T get()
        //Employee的空參構(gòu)造器：Employee()
        Supplier<Employee>  sup2 = Employee :: new;

        // Lambda寫法
        Function<Integer,Employee> func1 = id -> new Employee(id);

        //構(gòu)造器引用寫法
        //Function中的R apply(T t)
        Function<Integer,Employee> func2 = Employee :: new;

        // Lambda寫法
        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
        
        //構(gòu)造器引用寫法
        //BiFunction中的R apply(T t,U u)
        BiFunction<Integer,String,Employee> func2 = Employee :: new;

數(shù)組引用

可以把數(shù)組看做是一個(gè)特殊的類，則寫法與構(gòu)造器引用一致。

        // Lambda寫法
        Function<Integer,String[]> func1 = length -> new String[length];

        //數(shù)組引用
        //Function中的R apply(T t)
        Function<Integer,String[]> func2 = String[] :: new;