若Lambda體中的內容有方法已經實現了，我們可以使用“方法引用”，可以理解為方法引用是lambda表示式的另外一種表達形式

主要有三種語法格式：

• 物件 :: 例項方法名
• 類 :: 靜態方法名
• 類 :: 例項方法名

被引用的方法的引數和返回值必須和要實現的抽象方法的引數和返回值一致

1.靜態方法引用

//格式：Classname :: staticMethodName  和靜態方法呼叫相比，只是把 . 換為 ::
String::valueOf   等價於lambda表示式 (s) -> String.valueOf(s)
Math::pow       等價於lambda表示式  (x, y) -> Math.pow(x, y);
 

2.例項物件方法引用

//格式：instanceReference::methodName
class ComparisonProvider{
    public int compareByName(Person a, Person b){
        return a.getName().compareTo(b.getName());
    }
    public int compareByAge(Person a, Person b){
        return a.getBirthday().compareTo(b.getBirthday());
    }
}
ComparisonProvider myComparisonProvider = new ComparisonProvider();
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);
 

3.超類上的例項方法引用

//格式：super::methodName

//還可以使用this

4.泛型類和泛型方法引用

public interface MyFunc<T> {
    int func(T[] als, T v);
}
public class MyArrayOps {
     public static <T> int countMatching(T[] vals, T v) {
         int count = 0;
         for (int i = 0; i < vals.length; i++) {
             if (vals[i] == v) count++;
         }
         return count;
     }
}
public class GenericMethodRefDemo {    
    public static <T> int myOp(MyFunc<T> f, T[] vals, T v) {
        return f.func(vals, v);
    }    
    public static void main(String[] args){
        Integer[] vals = {1, 2, 3, 4, 2, 3, 4, 4, 5};
        String[] strs = {"One", "Two", "Three", "Two"};
        int count;
        count=myOp(MyArrayOps::<Integer>countMatching, vals, 4);
        System.out.println("vals contains "+count+" 4s");
        count=myOp(MyArrayOps::<String>countMatching, strs, "Two");
        System.out.println("strs contains "+count+" Twos");
    }
}
 

5.構造器引用

通過函式式介面例項化類時可以用構造器引用，引用到的是方法引數個數和型別匹配的構造器

//格式：ClassName :: new，呼叫預設構造器。
//lambda方式
Supplier<Passenger> supplier1 = () -> new Passenger();
//構造器引用:通過型別推斷，引用無參構造器
Supplier<Passenger> supplier2 = Passenger::new;
//lambda方式
BiFunction<String, String, Passenger> function1 = (x, y) -> new Passenger(x, y);
//構造器引用:通過型別推斷，引用有兩個String引數的構造器
BiFunction<String, String, Passenger> function2 = Passenger::new;

6.陣列引用

//lambda方式

Function<Integer, String[]> fun1 = (x) -> new String[x];
String[] strs1 = fun1.apply(10);
//陣列引用
Function<Integer, String[]> fun2 = String[]::new;
String[] strs2 = fun2.apply(10);