1.什么是方法引用
方法引用是java8中特定情况下简化lambada表达式的一种语法糖，这里的特定情况是指当调用现有的方法时可以用方法引用替代lambada表达式，其他情况下，则不可以替代。
举个栗子：
public class MethodReferenceTest {
public static void main(String[] args) {
List city = Arrays.asList("beijing","shanghai","tianjin","wuhan");
//使用lambada表达式遍历
city.forEach(i -> System.out.println(i));
//使用方法引用
city.forEach(System.out::println);
}
}
以上使用lambada表达式和方法引用的效果是等价的，但是方法引用看着要更加简洁一些，其实方法引用可以看做是函数指针（虽然java没有指针的概念），一个指向现有的函数的指针。
方法引用左右使用“::”双冒号隔开，左边是具体的类，右面是调用的具体的方法。上面的out实际上是System类中的一个PrintStream类型的常量（声明为final），PrintStream是java中的一个类，上面“::”右边的println方法就在这个类中定义，这个类中除了println方法，还有print,printf等输出方法。
2.四种方法引用
Student类：
public class Student {
private String name;
private double score;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public Student(String name, double score) {
this.name = name;
this.score = score;
}
public Student() {
}
//静态方法（类方法）
public static int compareStudentByScore(Student student1, Student student2){
return (int) student1.getScore() - (int)student2.getScore();
}
//实例方法（对象方法）
public int compareStudentByName(Student student){
return this.getName().compareToIgnoreCase(student.getName());
}
}
StudentCompare类：
public class StudentCompare {
//实例方法（对象方法）
public int CompareStudentByScore(Student student1,Student student2){
return (int)student1.getScore() - (int)student2.getScore();
}
}
2.1静态方法引用（类名::静态方法名）：
举个栗子：
public class MethodReferenceTest1 {
public static void main(String[] args) {
Student student1 = new Student("周明",75);
Student student2 = new Student("赵凯",83);
Student student3 = new Student("李强",97);
Student student4 = new Student("孙国",62);
List students = Arrays.asList(student1,student2,student3,student4);
students.sort(Student::compareStudentByScore); //静态方法引用
students.forEach(student -> System.out.println(student.getScore()));
}
}
上面(Student::compareStudentByScore静态方法引用，注意和静态方法调用Student.compareStudentByScore()是没有任何关系的，静态方法引用是一种表达式，lambada表达式的语法糖，参数默认传入，自己不能传入参数。静态方法调用是一种方法的调用形式，不能作为表达式使用，若有参数需要自己传入参数。
2.2实例方法引用（对象名::实例方法名）：
举个栗子：
public class MethodReferenceTest1 {
public static void main(String[] args) {
Student student1 = new Student("周明",75);
Student student2 = new Student("赵凯",83);
Student student3 = new Student("李强",97);
Student student4 = new Student("孙国",62);
List students = Arrays.asList(student1,student2,student3,student4);
StudentCompare studentCompare = new StudentCompare();//创建实例
students.sort(studentCompare::CompareStudentByScore); //实例方法引用
students.forEach(student -> System.out.println(student.getScore()));
}
}
和上面静态方法引用运行结果一样。实例方法引用就是在进行方法引用之前需要创建实例，通过实例对象名去引用方法。
2.3类的实例方法引用（类名::实例方法名）
在方法调用中，是不能用类名直接调用实例方法的，但在方法引用中是可以有 类名::实例方法名 这种形式的。
举个栗子：
public class MethodReferenceTest1 {
public static void main(String[] args) {
Student student1 = new Student("周明",75);
Student student2 = new Student("赵凯",83);
Student student3 = new Student("李强",97);
Student student4 = new Student("孙国",62);
List students = Arrays.asList(student1,student2,student3,student4);
students.sort(Student::compareStudentByName);
students.forEach(student -> System.out.println(student.getName()));
}
}
通过以上示例，我们讨论一下是谁调用的compareStudentByName方法
表面上看，是类Student类调用了compareStudentByName方法，但是Student是类，而compareStudentByName不是静态方法，只是实例方法，所以Student类是不能调用compareStudentByName的，那么又是谁调用了compareStudentByName方法呢，解决这个疑问，我们需要跟进一下List接口的sort方法，这是一个默认方法，sort方法的参数是一个Comparator的函数式接口，该接口的抽象方法compare方法有两个参数，源码如下：
default void sort(Comparator c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
@FunctionalInterface
public interface Comparator {
int compare(T o1, T o2);
}
而我们的Student类的compareStudentByName方法在对name进行比较时，实际上调用的是String类的compareToIgnoreCase，而该方法调用的还是Comparator接口的compare方法，源码如下：
public int compareToIgnoreCase(String str) {
return CASE_INSENSITIVE_ORDER.compare(this, str);
}
所以我们可以知道，当我们执行 students.sort(Student::compareStudentByName); 这句代码的时候，sort方法参数中lambada表达式的参数有两个，而我们的compareStudentByName方法只有一个参数，这要求的参数个数和我们传入的参数个数根本对应不上呀，
那么lambada的另一个参数是谁呢？我在刚看这块源码的时候其实也有疑惑。那么下面我们使用lambada表达式举个栗子，而不使用方法引用：
public class MethodReferenceTest2 {
public static void main(String[] args) {
List city = Arrays.asList("beijing","shanghai","tianjin","wuhan");
city.sort((city1,city2) -> city1.compareToIgnoreCase(city2));
//city.sort(String::compareToIgnoreCase);这句使用方法引用代码的效果和上面是一样的
city.forEach(System.out::println);
}
}
通过上面的栗子，我们可以看到，sort方法的参数中lambada表达式的两个参数有一个作为调用compareToIgnoreCase方法的对象，另一个参数作为compareToIgnoreCase方法的参数，进行比较。
回到上面 students.sort(Student::compareStudentByName)的sort方法参数中的lambada表达式的另一个参数是谁的问题，现在已经不难理解了，另一个参数就是compareStudentByName方法的调用者，this(Student的当前实例)，在Student类中：
public int compareStudentByName(Student student){
return this.getName().compareToIgnoreCase(student.getName());
}
所以对于 students.sort(Student::compareStudentByName) 这句代码中不是Student类调用的compareStudentByName的论断就很好理解了，类是当然不能调用实例方法了，实例方法需要类的对象实例来调用，而compareStudentByName方法就是Student的当前对象实例this调用的。
针对以上类的实例方法引用的问题，一般lambada表达式的第一个参数作为实例方法的调用者，其余参数作为实例方法的参数传入。
2.4构造方法引用（类名::new）
构造方法引用就是通过new调用构造方法，创建一个对象。
public class MethodReferenceTest3 {
public static void main(String[] args) {
System.out.println(getString(String::new)); //等价于System.out.println(getString(() -> new String()));
System.out.println(getString1("hello",String::new));
}
private static String getString(Supplier stringSupplier){
return stringSupplier.get()+"hello";
}
private static String getString1(String str,Function function){
return function.apply(str);
}
}
以上的示例通过构造方法引用创建String类的对象实例。