Java语法中的方法引用：：是个什么鬼？

钢铁的面条

已于 2023-03-09 16:33:36 修改

阅读量692

点赞数 1

文章标签： java 开发语言 jvm

于 2023-03-08 17:56:05 首次发布

本文链接：https://blog.youkuaiyun.com/m0_53653818/article/details/129406851

版权

case2：正式工作中用的比较多的stream流应用

case3：调用对象方法

case4："::new"实例化对象

总结

1.函数式接口

函数式接口（Functional Interface）就是一个有且仅有一个抽象方法（通俗来说就是只有一个方法要去被实现，因此我们也能通过这个去动态推断参数类型），但是可以拥有多个非抽象方法的接口。函数式接口可以被隐式转换为lambda表达式。通常被用在Lambda表达式和方法引用上。

2.Lambda表达式与"::"方法引用

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。方法引用提供了一种引用而不执行方法的方式，它需要由兼容的函数式接口构成的目标类型上下文。计算时，方法引用会创建函数式接口的一个实例。

当Lambda表达式中只是执行一个方法调用时，不用Lambda表达式，直接通过方法引用的形式可读性更高一些。方法引用是一种更简洁易懂的Lambda表达式

举例：

package com.yukuanyan.entity;

public class Person {
    private String name;

    private Integer age;

    public Person() {}

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

    public static int compare(Person a,Person b) {
        int r = a.getAge().compareTo(b.getAge());
        if (r != 0) {
            return r;
        } else {
            return a.getName().compareTo(b.getName());
        }
    }

    public static int compare(Person a,Person b,Person c) {
        return 0;
    }

    public Person concat(Person b) {
        this.setName(this.getName() + "," + b.getName());
        System.out.println(this);
        return this;
    }

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

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

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }
}

case1：

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class case1 {

    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));

        // 传统写法
        personList.sort(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() - o2.getAge();
            }
        });

        // Lambda 写法
        personList.sort((a,b) -> Person.compare(a,b));

        // 方法引用写法，调用static方法，参数类型动态推断
        personList.sort(Person::compare);

        System.out.println(personList);
    }
}

相信这里很多小伙伴会对方法引用写法有所疑问，明明Person类中有两个compare方法，java编译器是怎么直到应该使用哪个compare方法的呢？其实很简单。

我们点进去sort方法，sort方法需要传入一个函数式接口Comparator的实例

我们点进Comparator这个接口

可以看到抽象方法只有compare和equals，因为equals是继承自Object类，因此属于这个接口的抽象方法其实只有compare这一个接口，因此是符合函数式接口的定义的。

我们重点把目光放在compare接口的参数上，可以看到是

int compare(T o1, T o2);

参数是两个，类型都是泛型。所以当我们引用Person类中的compare方法时，也会被java编译器推断出我们要使用的是两个参数的compare，而不是三个参数的compare

case2：正式工作中用的比较多的stream流应用

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

import java.util.Arrays;
import java.util.List;

public class case2 {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));

        personList.stream().sorted(Person::compare).forEach(System.out::println);
    }
}

case3：调用对象方法

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

import java.util.Arrays;
import java.util.List;

public class case3 {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));
        Person p = new Person("zhaoliu",44);
        personList.stream().sorted(Person::compare).forEach(p::concat);

    }
}

case4："::new"实例化对象

package com.yukuanyan.cases;

import com.yukuanyan.entity.Person;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class case4 {
    public static void main(String[] args) {
        List<Person> personList = Arrays.asList(new Person("zhangsan",33),new Person("lisi",22),new Person("wangwu",11));
        Person p = new Person("zhaoliu",44);
        personList.stream().sorted(Person::compare).collect(Collectors.toCollection(ArrayList::new));

    }
}