介绍

方法引用提供了非常有用的语法，可以直接引用已有Java类或对象（实例）的方法或构造器。与lambda联合使用，方法引用可以使语言的构造更紧凑简洁，减少冗余代码。

注意

1. 被引用的方法，参数要和接口中抽象方法的参数一样；
2. 当接口抽象方法有返回值时，被引用的方法也必须也返回值；

方法引用的格式

• 符号表示：::
• 符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用
• 应用场景：如果 Lambda 所要实现的方案，已经有其他方法存在相同方案，那么则可以使用方法引用

场景引用方式

1. instanceName::methodName（对象::方法名）
2. ClassName::staticMethodName（类名::静态方法）
3. ClassName::methodName（类名::普通方法）实例方法会将第一个参数作为方法调用者
4. ClassName::new（对象::new）调用的构造器
5. TypeName[]::methodName（String[]::new）调用数组的构造器

场景引用样例

对象::方法名

import java.util.Date;
import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {
        // 准备一个 Date 对象，获取时间戳
        Date now = new Date();
        // 方案一：Lambda 表达式
        Supplier<Long> time1 = () -> {
            return now.getTime();
        };
        // 方案二：方法引用
        Supplier<Long> time2 = now::getTime;
    }
}

类名::静态方法

import java.util.function.Supplier;

public class Demo {
    // 利用 system 的静态方法获取当前毫秒
    public static void main(String[] args) {
        // 方案一：Lambda 表达式
        Supplier<Long> time1 = () -> {
            return System.currentTimeMillis();
        };
        // 方案二：方法引用
        Supplier<Long> time2 = System::currentTimeMillis;
    }
}

类名::普通方法

import java.util.function.Function;

public class Demo {
    // 获取字符串长度
    public static void main(String[] args) {
        // 方案一：Lambda 表达式
        Function<String, Integer> f1 = (str) -> {
            return str.length();
        };
        Integer length1 = f1.apply("hello");
        // 方案二：方法引用（在这里，String 的 length 方法会将第一个参数 "hello" 作为方法调用者）
        Function<String, Integer> f2 = String::length;
        Integer length2 = f2.apply("hello");
    }
}

构造器

import java.util.function.BiFunction;
import java.util.function.Supplier;

public class Demo {
    public static void main(String[] args) {
        // 无参构造
        build1();
        // 有参构造
        build2();
    }

    /** 无参构造 */
    public static void build1(){
        // 方案一：Lambda 表达式
        Supplier<Person> s1 = () -> {
            return new Person();
        };
        Person p1 = s1.get();
        // 方案二：方法引用
        Supplier<Person> s2 = Person::new;
        Person p2 = s2.get();
    }

    /** 有参构造 */
    public static void build2(){
        // 方案一：Lambda 表达式
        BiFunction<String, Integer, Person> b1 = (String name, Integer age) -> {
            return new Person(name, age);
        };
        Person p1 = b1.apply("张三", 24);
        // 方案二：方法引用
        BiFunction<String, Integer, Person> b2 = Person::new;
        Person p2 = b2.apply("张三", 24);
    }
}

class Person {
    private String name;
    private Integer age;

    public Person(){}

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

数组的构造器

import java.util.function.Function;

public class Demo {
    public static void main(String[] args) {
        // 方案一：Lambda 表达式
        Function<Integer, int[]> f1 = (Integer length) -> {
            return new int[length];
        };
        int[] arr1 = f1.apply(10);
        // 方案二：方法引用
        Function<Integer, int[]> f2 = int[]::new;
        int[] arr2 = f2.apply(10);
    }
}