函數式編程，方法引用，Java雙冒號（::）示例詳解

第一部分

方法引用，又稱雙冒號（::），是簡化的lambda表達式，主要使用形式包括四種：

方法引用的形式（Kinds of Method References）

類型	Kind	Example
指向靜態方法的引用	Reference to a static method	ContainingClass::staticMethodName
指向特定對象實例方法的引用	Reference to an instance method of a particular object	containingObject::instanceMethodName
指向特定類型任意對象實例方法的引用	Reference to an instance method of an arbitrary object of a particular type	ContainingType::methodName
指向構造函數的引用	Reference to a constructor	ClassName::new

 考慮以下例子：

Person類

import java.time.LocalDate;

public class Person {

    public enum Sex {
        MALE, FEMALE
    }

    String name;
    LocalDate birthday;
    Sex gender;
    String emailAddress;

    public Person(String name, LocalDate birthday, Sex gender) {
        this.name = name;
        this.birthday = birthday;
        this.gender = gender;
    }

    public int getAge() {
        int age = LocalDate.now().minusYears(birthday.getYear()).minusDays(birthday.getDayOfYear()).getYear();
        return age;
    }

    public LocalDate getBirthday() {
        return birthday;
    }

    public static int compareByAge(Person a, Person b) {
        return a.birthday.compareTo(b.birthday);
    }
}

如果對Person數組排序，可通過下面這種方式，先聲明一個類，然后實例化。

①實例化類的寫法：

List<Person> roster = Arrays.asList();

Person[] rosterAsArray = roster.toArray(new Person[roster.size()]);

class PersonAgeComparator implements Comparator<Person> {
    public int compare(Person a, Person b) {
        return a.getBirthday().compareTo(b.getBirthday());
    }
}

Arrays.sort(rosterAsArray, new PersonAgeComparator());

靜態方法sort的方法簽名：

static <T> void sort(T[] a, Comparator<? super T> c)

Comparator是一個函數式接口

@FunctionalInterface
public interface Comparator<T> {
    
    int compare(T o1, T o2);
}

②可以通過lambda表達式，替換創建一個類：

返回值為compare的方法體

Arrays.sort(rosterAsArray,
    (Person a, Person b) -> {
        return a.getBirthday().compareTo(b.getBirthday());
    }
);

③單獨的表達式，可以去掉return和大括號，寫法為：

Arrays.sort(rosterAsArray, (Person a, Person b) -> a.getBirthday().compareTo(b.getBirthday()));

④參數類型可以自動推斷，可以去掉參數類型：

Arrays.sort(rosterAsArray, (a, b) -> a.getBirthday().compareTo(b.getBirthday()));

⑤方法引用可以使代碼進一步簡潔：

Arrays.sort(rosterAsArray, Person::compareByAge);

下面示例演示4種類型

1）指向靜態方法的引用

Arrays.sort(rosterAsArray, Person::compareByAge);

2）指向類實例方法的引用

1 String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" }; 2 Arrays.sort(stringArray, String::compareToIgnoreCase);

3）指向特定類型任意對象實例方法的引用

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);

4）指向構造函數的引用

有如下方法，將一個集合轉為另外一個集合

public static <T, SOURCE extends Collection<T>, DEST extends Collection<T>>
    DEST transferElements(
        SOURCE sourceCollection,
        Supplier<DEST> collectionFactory) {
        
        DEST result = collectionFactory.get();
        for (T t : sourceCollection) {
            result.add(t);
        }
        return result;
}

轉換如下：

Set<Person> rosterSetLambda = transferElements(roster, () -> { return new HashSet<>(); });

簡潔寫法如下：

Set<Person> rosterSet = transferElements(roster, HashSet::new);

上述代碼隱藏了泛型：

Set<Person> rosterSet = transferElements(roster, HashSet<Person>::new);

以上參考自：https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

- - - - - - - - - - - - - - - - - - - - 分割線 - - - - - - - - - - - - - - - - - - - - 

第二部分

下面結合方法引用對應的（內置）函數式接口，通過代碼示例，詳細解說。

雙冒號（::）和 箭頭函數（->）一並展示如下：

如：HashMap::new  等同於  ( ) -> new HashMap()

熟悉方法引用對應的函數式接口很重要，因為它是方法的參數。熟悉了它，可以結合Java高級特性（泛型、反射等）寫出抽象可復用的函數式代碼。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;

public class Test {

    // 實例對象引用實例方法
    Supplier<String> supplier1 = "lowerCase"::toUpperCase;
    Supplier<String> supplier1_1 = () -> "lowerCase".toUpperCase();

    // 類引用(無參)構造函數
    Supplier<String> supplier2 = String::new;
    Supplier<String> supplier2_1 = () -> new String();

    // 類引用(有參）構造函數
    Function<String, String> function1 = String::new;
    Function<String, String> function1_1 = (String str) -> new String(str);

    // 類引用實例方法，入參為傳入實例對象，入參、出參同類型
    Function<String, String> function2 = String::toUpperCase;
    Function<String, String> function2_1 = (String str) -> str.toUpperCase();

    // Predicate<T>可理解為特殊的Function<T, Boolean>

    Person person = new Person();
    // 須為無參靜態方法
    Supplier<Boolean> supplierBln = Person::isTest;
    Supplier<Boolean> supplierBln_1 = () -> Person.isTest();

    // 實例對象調用實例方法
    Supplier<String> supplierStr = person::getName;
    Supplier<String> supplierStr_1 = () -> person.getName();

    // 無參構造函數
    Supplier<Person> supplierPerson = Person::new;
    Supplier<Person> supplierPerson_1 = () -> new Person();

    // 有參構造函數
    BiFunction<String, String, Person> biFunction = Person::new;
    BiFunction<String, String, Person> biFunction_1 = (name, gender) -> new Person(name, gender);
    
    // 類名調用set方法，特定場景下，可取代反射
    BiConsumer<Person, String> biConsumer = Person::setName;

    // 類名調用實例方法，入參為傳入實例對象
    Function<Person, Person> functionP = Person::toOpposite;
    Function<Person, Person> functionP_1 = person -> person.toOpposite();

    Consumer<String> consumer = System.out::println;
    Consumer<String> consumer_1 = (String str) -> System.out.println(str);;

    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "2", "3");
        boolean bl = list.stream().anyMatch("1"::equals);
        List<String> retval = list.stream().collect(Collectors.toCollection(LinkedList::new));

        List<Person> persons = Arrays.asList(new Person(10, "Jack", "M"));
        Person person = new Person(20, "Lily", "F");
        persons.stream().filter(Person::isMale).filter(person::isUnder).collect(Collectors.toCollection(ArrayList::new));
    }
}

Person類代碼如下：

public class Person {
    int age;
    String name;
    String gender;

    public Person() {
    }

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

    public Person(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }

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

    public String getName() {
        return name;
    }

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

    public Person toOpposite() {
        if (gender.charAt(0) == 'M')
            gender = "F";
        else
            gender = "M";
        return this;
    }

    public static boolean isTest() {
        return true;
    }

    public boolean isUnder(Person person) {
        return person.age > this.age;
    }

    public boolean isMale() {
        return gender.equals("M");
    }
}

 - - - - - - - - - - - - - - - - - - - - 分割線 - - - - - - - - - - - - - - - - - - - - 

第三部分

擴展至自定義的函數式接口

下面結合Elasticsearch，進一步實例講解

指向類靜態方法的引用

NodesUsageResponse節點使用響應，50行使用了方法引用

 泛型方法，入參為函數Reader<V>

函數式接口Reader<V>，定義了方法reader(StreamInput in）：

reader.read(this)實際調用函數是

 

第三種類型

指向特定類型任意對象實例方法的引用（Reference to an Instance Method of an Arbitrary Object of a Particular Type）

TransportService傳輸服務，構造函數164行使用了方法引用

 

成員變量asyncSender和interceptor

 

作用為請求發送攔截器接口TrsnsportInterceptor，調用的為49行，返回AsyncSender函數式接口，57行為函數式接口定義。

TransportService構造函數，使用了類實例方法sendRequestInternal

sendRequestInternal( Connection connection, String action, TransportRequest request, TransportRequestOptions options, TransportResponseHandler<T> handler)

方法sendRequestInternal的方法參數列表、返回值類型和接口TransportInterceptor中的函數是接口AsyncSender一致。

第四種類型

指向構造函數的應用

構造函數，以67行為例

泛型方法 StreamInput # readOptionalWriteable

方法引用DiscoveryNode::new，實際調用構造函數如下