前言：

接上一篇文章：Java8新特性（內建的核心函式式介面）http://blog.csdn.net/xinghuo0007/article/details/78603908

我們知道使用了Lambda表示式以後能夠是我們的程式碼的精簡，而且可讀性更強，但是有時Lambda表示式的Lambda體內的功能我們已經實現過了，
這個時候就可以使用我們的函式引用、構造器引用了

知識點一：方法引用

什麼是方法引用？

 答：方法引用是對Lambda表示式符合某種情況下的一種縮寫，使得我們的Lambda表示式更加的精簡，
 也可以理解為Lambda表示式的另一種表現形式（縮寫）

什麼時候使用方法引用呢？

答：當要傳遞給Lambda體內的操作，已經有實現的方法了，就可以使用方法引用了

方法引用使用的前提條件是什麼呢？

答：
    1.方法引用所引用的方法的引數列表必須要和函式式介面中抽象方法的引數列表相同（完全一致）

    2.方法引用所引用的方法的的返回值必須要和函式式介面中抽象方法的返回值相同（完全一致）

方法引用有什麼語法格式嗎？

方法引用一般有三種格式：

    1. 例項物件名::例項方法名
    2. 類名::靜態方法名
    3. 類名::例項方法名              (注意區別2，3的區別，下面會說)

2，3的區別：
    若Lambda 的引數列表的第一個引數，是例項方法的呼叫者，第二個引數(或無參)是例項方法的引數時，格式： 類名::
 
例項方法名 

方法引用舉例：

舉例一：1. 例項物件名::例項方法名（案例一）

        Student student = new Student("XiangYang",23);
        Supplier<String> supplier = ()->student.getName();
        System.out.println("Lambda形式： "+supplier.get());


        Supplier<String> supplier1 = student :: getName;
        System.out
 
.println("方法引用形式： "+supplier1.get());



class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }



    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

舉例一： 1. 例項物件名::例項方法名 （案例二）

   @org.junit.Test
    public void test6(){
        //傳統Lambda表示式
        Consumer<String> consumer = (x) -> System.out.println(x);
        consumer.accept("Hi: 我是Lambda表示式實現的！"); //列印：Hi: 我是Lambda表示式實現的！
        //方法引用實現
        consumer = System.out::println;
        consumer.accept("Hello : XiangYang，我是使用方法引用實現的 ");//列印：Hello : XiangYang，我是使用方法引用實現的 
    }

舉例二： 2. 類名::靜態方法名

 public class Test{
     @org.junit.Test
    public void test8(){
        //傳統Lambda表示式
        Consumer<String> consumer = (str) -> sop(str);
        consumer.accept("Hello : XiangYang"); //列印：Hello : XiangYang

        //方法引用方式
        consumer = Test::sop;
        consumer.accept("Hello : XiangYang"); //列印：Hello : XiangYang
    }
}

舉例三： 3. 類名::例項方法名

    @org.junit.Test
    public void test7(){
        //傳統Lambda表示式
        BiPredicate<String,String> biPredicate = (x,y) -> x.equals(y);
        boolean test = biPredicate.test("hello", "hi");
        System.out.println(test);//false

        //方法引用
        biPredicate = String::equals;
        test = biPredicate.test("hello", "hello");
        System.out.println(test);//true

    }

注意：

1.這裡一定要知道 類名::例項方法名  這種語法的使用條件：
  說明：a，b是所有方法引用的必要條件，c是使用 類名::例項方法名的特殊前提

    a.方法引用所引用的方法的引數列表必須要和函式式介面中抽象方法的引數列表相同（完全一致）

    b.方法引用所引用的方法的的返回值必須要和函式式介面中抽象方法的返回值相同（完全一致）

    c.若Lambda 的引數列表的第一個引數，是例項方法的呼叫者，第二個引數(或無參)是例項方法的引數時，格式： 類名::例項方法名 

2.解釋一下：
    首先看一下使用傳統Lambda表示式的形式：
        //傳統Lambda表示式
        BiPredicate<String,String> biPredicate = (x,y) -> x.equals(y);
        boolean test = biPredicate.test("hello", "hi");
        System.out.println(test);//false

    注意看： equals方法的呼叫者是x，equals方法引數是y，這符合我們上面的c條件；所以能使用

方法引用總結：

1.一定弄明白使用方法引用的前提條件（2個）

    a. 方法引用所引用的方法的引數列表必須要和函式式介面中抽象方法的引數列表相同（完全一致）

    b .方法引用所引用的方法的的返回值必須要和函式式介面中抽象方法的返回值相同（完全一致）

  這裡使用程式碼解釋一下：

    @org.junit.Test
    public void test6(){
        //傳統Lambda表示式
        Consumer<String> consumer = (x) -> System.out.println(x);
        consumer.accept("Hi: 我是Lambda表示式實現的！"); //列印：Hi: 我是Lambda表示式實現的！
        //方法引用實現
        consumer = System.out::println;
        consumer.accept("Hello : XiangYang，我是使用方法引用實現的 ");//列印：Hello : XiangYang，我是使用方法引用實現的 
    }

解釋：
    1.首先我們看一下Consumer的函式式介面的原始碼的介面
        void accept(T t);
     由於我們給泛型傳入的是String型別
          Consumer<String> consumer = (x) -> System.out.println(x);
     所以此時

      //這是函式式介面中抽象方法，接收了實際型別String，沒有返回值
       void accept(T t); ==》 void accept(String t); 
    2 我們在看我們的Lambda體內的實現      
         System.out.println(x);
      此時，我們檢視println方法的原始碼：

    //這是 方法引用所引用的方法 的引數型別是String，無返回值
    public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }

  3. 此時函式式的介面中的引數型別與返回值 和   方法引用所引用方法的引數型別與返回值相同，所以可以使用方法引用，型別為： 例項物件名:: 例項方法名 

知識點二：構造器引用

什麼是構造器引用？

答：與函式式介面相結合，自動與函式式介面中方法相容。
可以把構造器引用賦值給定義的方法。 

什麼時候用構造器引用？

答：在使用Lambda表達的時，滿足使用構造器引用條件的時候可以使用

構造器使用的前提是什麼？

答：構造器引數列表要與介面中抽象方法的引數列表一致！

構造器引用的語法格式是什麼？

語法格式：
    類名 :: new 

舉例：

說明：Student類見方法引用舉例一的案例

  @org.junit.Test
    public void  test9(){

        //傳統Lambda方式
        Supplier<Student> studentSupplier = ()-> new Student();
        Student student = studentSupplier.get();
        System.out.println(student);//Student{name='null', age=0}

        //構造器引用
        studentSupplier = Student::new;
        student = studentSupplier.get();
        System.out.println(student);//Student{name='null', age=0}
    }

案例說明：

1.首先我們要只是Supplier介面的抽象方法定義為：
       T get();
    我們程式碼
        Supplier<Student>此時已經泛型T傳入Student型別
    相當於：
      Student get(); //函式式介面中是無參，返回值為Student
2.在看我們的Student類的定義中一個無參構成器
     Student(){} //構造器無參，返回Student型別（嚴格意義上兩個構成函式沒有返回值，我們先這樣理解）

3.此時，符合我們使用構造方法引用的前提：
        構造器引數列表要與介面中抽象方法的引數列表一致！
  所以：可以使用構造引用。          

知識點三：陣列引用

 說明： 
     這裡單獨把陣列引用拿出來實際上是強調一下，陣列引用和構造引用基本相同，直接上一個案例來說明問題

案例：

 @org.junit.Test
    public void test10(){
        //需求：獲取n個int[] 陣列

        //傳統Lambda實現
        Function<Integer,int[]> function = (i) -> new int[i];
        int[] apply = function.apply(5);
        System.out.println(apply.length); // 5

        //陣列型別引用實現
        function = int[] ::new;
        apply = function.apply(10);
        System.out.println(apply.length); // 10
    }