日积月累，水滴石穿 😄

什么是方法引用

方法引用是Lambda表达式的另外一种表现形式，是一个语法糖。那为什么要使用方法引用呢？

当 Lambda 体中的具体实现，已经有其他方法帮我们实现过了，那这时候我们就可以使用方法引用。也就是说使用 方法引用 可以少写一些代码，提高工作效率。使用方法引用的时候 需要保证引用方法的参数列表、返回值类型与我们当前所要实现的函数式接口方法的参数列表、返回值类型保持一致。

语法格式

对象::实例方法名

 @Test
public void test1(){
    Consumer<String> con = (x) ->System.out.println(x);
    //执行 Lambda 体
    con.accept("gongj");

    //简写
    Consumer<String> con2 = System.out::println;
    con2.accept("yuanj");
}

注意，这样写的前提: accept()方法和println()方法的参数列表和返回类型要完全一致:

先准备一个 Employee对象

   public class Employee {
    private String name;
    private int age;
    private double salary;

    public Employee() {
    }
    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

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

    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public double getSalary() {
        return salary;
    }

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

再看一个例子

@Test
public void test2(){

    Employee emp = new Employee("gongj",122,7888);

    Supplier<String> sup = () -> emp.getName();
    System.out.println(sup.get());

    //简写
    Supplier<String> sup2 = emp::getName;
    System.out.println(sup2.get());
}

类::静态方法名

@Test
public void test3() {
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    com.compare(1, 2);

    // 使用方法引用的方式
    Comparator<Integer> com1 = Integer::compare;
    com1.compare(1, 2);
}

类::实例方法名

@Test
public void test4(){
    BiPredicate<String,String> bp = (x,y) -> x.equals(y);
    System.out.println(bp.test("gognj","dddd"));

    BiPredicate<String,String> bp2 = String::equals;
    System.out.println(bp.test("gognj","gognj"));
}

使用注意: 若Lambda参数列表中的第一个参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用 类::实例方法名。 这种方法引用的方式就不需要满足保证引用方法的参数列表、返回值类型与我们当前所要实现的函数式接口方法的参数列表、返回值类型保持一致这一规则了

构造器引用

语法格式：类::new，调用哪个构造器取决于函数式接口中的方法形参的定义，Lambda 会自动根据接口方法推断出你要调用的构造器，也就是说 需要调用的构造器的参数列表要与函数式接口中的抽象方法的参数列表保持一致

• 调用无参构造器

@Test
public void test5(){
   Supplier<Employee> sup = () -> new Employee();
   
   //构造器引用  这里调用的是无参构造器
   Supplier<Employee> sup2 = Employee::new;
   System.out.println(sup2.get());
}
结果：
name='null', age=0, salary=0.0

• 调用有参构造器

@Test
public void test6(){
    Function<String,Employee> fun = (x) -> new Employee(x);
    System.out.println(fun.apply("gongj"));

    Function<String,Employee> fun2 = Employee::new;
    System.out.println(fun2.apply("yuanj"));
}
结果：
name='gongj', age=0, salary=0.0
name='yuanj', age=0, salary=0.0

如果想要匹配多个的，(两个的可以使用BiFunction)，下面看一个三个参数的，自定义一个函数式接口：

@FunctionalInterface
public interface MyFun2<T,A,B, R> {

    R apply(T t,A a,B b);
}

测试

 @Test
    public void test7(){

        MyFun2<String,Integer, Double,Employee> fun = Employee::new;
        System.out.println(fun.apply("gongj",99999d));
    }
结果：
name='gongj', age=25, salary=99999.0

数组引用

语法格式为 Type[]::new

    @Test
    public void test8() {
        Function<Integer, String[]> fun = (x) -> new String[x];
        String[] apply = fun.apply(10);
        System.out.println(apply.length);

        // 数组引用
        Function<Integer, String[]> fun1 = String[]::new;
        String[] apply2 = fun1.apply(10);
        System.out.println(apply2.length);
    }
结果：
10
20

• 如你对本文有疑问或本文有错误之处，欢迎评论留言指出。如觉得本文对你有所帮助，欢迎点赞和关注。