函数式编程，方法引用，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，实际调用构造函数如下