一句话介绍：

方法引用（Method Reference）是在 Lambda 表达式的基础上引申出来的一个功能。

先不铺展概念，从一个示例开始说起。

一、小示例

List<Integer> list = Arrays.asList(1, 2, 3);
list.forEach(num -> System.out.println(num));

上面是一个很普通的 Lambda 表达式：遍历打印列表的元素。

相比 JDK8 版本以前的 for  循环或 Iterator 迭代器方式，这种 Lambda 表达式的写法已经是一种很精简且易读的改进。但有没有更精简的改进？

答案是有！下面就有请方法引用出场：

list.forEach(System.out::println);

没用过这种方式的小伙伴，可能会纳闷：这是什么鬼？为什么编译器竟然不报错？该怎么理解？

这其实就是一种方法引用。中间的两个冒号“::”，就是 Java 语言中方法引用的特有标志，出现它，就说明使用到了方法引用。

因为 Foreach() 方法的形参是 Consume<T> 对象，所以，上面方法引用的方式等同于如下表达：

Consumer<Integer> consumer = System.out::print;
list.forEach(consumer);

有木有很神奇？System.out::print  语句的左值可以是一个 Consumer 对象。从编译器的角度来理解，等号右侧的语句是一种方法引用，那么编译器会认为该语句引用的是 Consumer 接口的 accept(T t) 抽象方法。

下面来细细拆分一下输出语句：System.out.println(); 。

System 是一个可不变类，包含了多个域变量和静态方法，之所以能使用 System.out 这种形式，就因为 out 是它的一个静态变量，且是一个  PrintStream  对象：

/**
 * The "standard" output stream. This stream is already
 * open and ready to accept output data. Typically this stream
 * corresponds to display output or another output destination
 * specified by the host environment or user.
 * <p>
 * For simple stand-alone Java applications, a typical way to write
 * a line of output data is:
 * <blockquote><pre>
 *     System.out.println(data)
 * </pre></blockquote>
 * <p>
 * See the <code>println</code> methods in class <code>PrintStream</code>.
 *
 * @see     java.io.PrintStream#println()
 * @see     java.io.PrintStream#println(boolean)
 * @see     java.io.PrintStream#println(char)
 * @see     java.io.PrintStream#println(char[])
 * @see     java.io.PrintStream#println(double)
 * @see     java.io.PrintStream#println(float)
 * @see     java.io.PrintStream#println(int)
 * @see     java.io.PrintStream#println(long)
 * @see     java.io.PrintStream#println(java.lang.Object)
 * @see     java.io.PrintStream#println(java.lang.String)
*/
public final static PrintStream out = null;

而 println(xxx) 是 PrintStream 类里一个普通方法。println(xxx) 方法有多个重载，不同点在入参的类型，可以使 int、float、double、char、char[]、boolean、long 等。

public void println(T x) {
    synchronized (this) {
        print(x);
        newLine();
    }
}

前面啰嗦那么多，重点来了！

println(xxx)  方法的特点是只有一个入参，没有出参。这个和 Consumer<T>  函数式接口的 accept(T t)  是不是很像？这也是方法引用的精髓：

只要一个已存在的方法，其入参类型、入参个数和函数式接口的抽象方法相同（不考虑两者的返回值），就可以使用该方法（如本例中的 println(xxx)），来指代函数式接口的抽象方法（如本例中的  accept(T t) 方法），等于是该抽象方法的一种实现，也不需要继承该函数式接口。

直接用已存的类名 + 两个冒号 + 方法名即可：类名::方法名。注意，这里的方法名是不带括号的。

这个比 Lambda 表达式还省事，Lambda 表达式是在不继承接口的基础上，直接用形如  () -> {} 的方式变相实现了抽象方法，方法引用是直接用已存的方法来指代该抽象方法！

总结一下，方法引用解决了什么问题？

它解决了代码功能复用的问题，使得表达式更为紧凑，可读性更强，借助已有方法来达到传统方式下需多行代码才能达到的目的。

二、方法引用的语法

方法引用的语法很简单。

使用一对冒号 :: 来完成，分为左右两个部分，左侧为类名或对象名，右侧为方法名或 new 关键字。有以下四种类型：

## 方法引用的几种类型：
1、构造器引用，形式为 类名::new
2、静态方法引用，形式为 类名::方法名
3、类特定对象的方法引用，形式为 类对象::方法名
4、类的任意对象引用，形式为 类名::方法名

看个非常简单的示例，对应了上面的四种引用类型。

public class Animal {
    private String name;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

    public static Animal getInstance(Supplier<Animal> supplier) {
        return supplier.get();
    }

    public void guard(Animal animal) {
        System.out.println(this.getName() + " guard " + animal.getName());
    }

    public void sleep() {
        System.out.println(this.getName() + " sleep.");
    }

    public static void bodyCheck(Animal animal) {
        System.out.println("body check " + animal.getName());
    }
}

定义了一个简单的 Animal 类，包含了静态方法、普通方法、有参构造函数等。

接下来，我们看下基于这个  Animal 类，四种方法引用类型的使用：

public static void main(String[] args) {
    List<Animal> animalList = new ArrayList<Animal>() {{
        add(new Animal("sheep"));
        add(new Animal("cow"));
    }};

    System.out.println("---- 构造器引用 ----");
    Animal pig = Animal.getInstance(Animal::new);
    pig.sleep();

    System.out.println("\n---- 静态对象的引用 ----");
    animalList.forEach(Animal::bodyCheck);

    System.out.println("\n---- 类特定对象的引用 ----");
    Animal dog = new Animal("dog");
    animalList.forEach(dog::guard);

    System.out.println("\n---- 类的任意对象的引用 ----");
    animalList.forEach(Animal::sleep);
}

如果上面的代码你都理解了，那方法引用你也已经基本掌握了。

下面，针对方法引用的这几种类型，各自再详细解释。

三、方法引用的几种类型

3.1 构造器引用

语法很简单：类名::方法名，使用方式如下：

// 示例 1
Supplier<List<Integer>> supplier1 = ArrayList::new;
List<Integer> list = supplier1.get();

// 示例 2
Supplier<Animal> supplier2 = Animal::new;
Animal animal = supplier2.get();

之所以能赋值给 Supplier 接口，是因为其抽象方法 get() 没有入参，与类的无参构造函数一致。

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

这里还需要注意一点，自定义的类必须有“无参构造函数”，否则编译器会报错。

我们都知道，当创建一个类后，如果不显式声明构造函数，编译器会默认加一个无参构造函数。但如果有显式声明一个或多个有参构造函数，则编译器不再默认追加无参构造函数。如下：

public class Animal {
    private String name;

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

上面代码中的 Animal 类只有一个构造函数  Animal(String name)，不再有无参构造函数。这种方式下使用构造器引用就会报错：

Supplier<Animal> supplier = Animal::new; // 编译报错：Cannot resolve constructor 'Animal'

3.2 静态方法引用

语法为 类名::静态方法名。

还是以上面的 Animal 类为例，为了更好展示静态方法引用，相比上面的示例，我们适当做一下调整：

public class Animal {
    private String name;
    private Integer weight;

    public Animal() {
    }

    public Animal(String name, Integer weight) {
        this.name = name;
        this.weight = weight;
    }

    public String getName() {
        return name;
    }

    public Integer getWeight() {
        return weight;
    }

    ...

    public static void bodyCheck(Animal animal) {
        System.out.println("body check " + animal.getName());
    }

    public static Integer compareByName(Animal one, Animal another) {
        return one.getName().compareTo(another.getName());
    }

    public Integer compareByWeight(Animal one, Animal another) {
        return one.getWeight() - another.getWeight();
    }
}

Animal 类有两个成员变量 name 和 weight，它有多个方法，其中包括两个静态方法  compareByName() 和  compareByWeight()。

给定一个 Animal  对象列表，如果我们想根据名称排序，可以怎么做？你想到了几种方式？

• 第一种：利用 Collections.sort(List<T> list) 方法

这种方式，需要 Animal 类实现 Coparable<T> 接口，给出  compareTo(T t)  抽象方法的具体实现，如下所示：

public class Animal implements Comparable {

    ...

    @Override
    public int compareTo(Object o) {
        Animal another = (Animal)o;
        return this.getName().compareTo(another.toString());
    }
}

// 调用
Collections.sort(animalList);

这种方式在 JDK7 版本及以前使用的比较多。

• 第二种：利用  Collections.sort(List<T> list, Comparator<? super T> c) 方法

在集合类  Collections<T>  中，还有一个 sort(List<T> list) 的重载方法  sort(List list, Comparator<? super T> c)。

使用该方法，Animal 类就无需再实现 Comparable<T> 接口，在 JDK7 版本及以前，使用匿名内部类来调用此方法即可。

相比第一种方式，结构上轻便了很多，代码实现如下：

Collections.sort(animalList, new Comparator<Animal>() {
    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.getName().compareTo(o2.getName());
    }
});

• 第三种：利用 Lambda 表达式

和第二种类似，只不过随着  JDK8 版本中 Lambda 表达式的出现，可替换以往的匿名内部类，代码实现上做到更简洁：

// Lambda 表达式的实现
Collections.sort(animalList, (a, b) -> a.getName().compareTo(b.getName()));

• 第四种：借助方法引用

在第一种方式中，Animal 类还要实现 Comparable<T> 接口，然后做  compare()  抽象方法的具体实现。

整个实现上是过于笨重的，太形式化。

有了方法引用，就可以大大减轻这种不必要的形式化。因为 Animal 类中已经有了类似的比较方法，即静态方法  compareByName()。

直接用这个方法代替 compare() 方法不就行啦，如下：

Collections.sort(animalList, Animal::compareByName);

是不是很简单！没有接口实现，也没有匿名内部类，以一种优雅的方式达到了相同的目的，这也是方法引用的魅力之处。

我个人理解，方法引用的出现，就是为了去优化冗余且过于形式化的代码，直接用短平快的方式解决。

• 第五种：利用 List 接口的 sort() 默认方法

除了 Collections 集合类，List 接口中，也提供了列表的排序方法。

// 匿名内部类实现
animalList.sort(new Comparator<Animal>() {
    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.getName().compareTo(o2.getName());
    }
});

// Lambda 表达式实现
animalList.sort((a, b) -> a.getName().compareTo(b.getName()));

// 静态方法引用的实现
animalList.sort(Animal::compareByName);

• 第六种：Stream() 流排序

Stream() 流是 JDK8 中新引入的功能，排序代码如下：

// 方式 1：Lambda 表达式实现
animalList = animalList
    .stream()
    .sorted((a, b) -> a.getName().compareTo(b.getName()))
    .collect(Collectors.toList());

// 方式 2：静态方法引用
animalList = animalList
    .stream()
    .sorted(Animal::compareByName)
    .collect(Collectors.toList());

3.3 类特定对象的引用

在前一章节的第五种方式中，我们可以替换为类特定对象的引用。

语法：类对象::普通方法名。

在上面的 Animal 类中，有一个普通方法：

public Integer compareByWeight(Animal one, Animal another) {
    return one.getWeight() - another.getWeight();
}

compareByWeight() 就是一个普通的实例方法，但它的定义依然与 Comparable 接口的 compare()  抽象方法定义是一致的。所以也可以使用在方法引用中。

怎么使用呢？方式如下：

Animal dog = new Animal("dog", 40);
animalList.sort(dog::compareByWeight);

类特定对象的引用、静态方法引用，两者在使用上没有区别，都达到一样的目的，只是方式不同，一个是类 + 静态方法名，一个是类对象 + 普通方法名。

3.4 类的任意对象的引用

语法：类名::普通方法名。

从语法上看，与前面  2.3.2 小节的静态方法引用类似，都是类名 + 方法名的方式，只不过一个是普通方法，一个是静态方法，但这是不是意味着两者在含义上也是类似的呢？

答案是否定的。

对于  2.3.2 章节的静态方法引用，以及 2.3.3 章节的类特定对象的引用，它们的重点都是在引出方法，只不过引出的方式不同。

public class Animal {
    private String name;
    private Integer weight;

    public Animal(String name, Integer weight) {
        this.name = name;
        this.weight = weight;
    }

    ...

    public static Integer compareByName(Animal one, Animal another) {
        return one.getName().compareTo(another.getName());
    }

    public Integer compareByWeight(Animal one, Animal another) {
        return one.getWeight() - another.getWeight();
    }
}


// 静态方法引用
animalList.sort(Animal::compareByName);

// 类的特定对象的引用
Animal dog = new Animal("dog", 40);
animalList.sort(dog::compareByWeight);

就像上面的代码中，“类的特定对象的引用”示例中，换个 Animal 对象，依然能达到同样的效果：

Animal cat = new Animal("cat", 15);
animalList.sort(cat::compareByWeight);

好了，现在回到本小节的主题：类的任意对象的引用。

我们可以怎么用呢？

在继续讲之前，我们先回头再观察下前面面代码中的 compareByWeight(xx, xxx) 方法。有没有发现它的两个参数有点儿冗余？另外，如果是两个参数，这个方法放在任何一个类中都可以使用，完全可以把它抽到一个工具类中使用，没必要放在这个类中。如果要放在该类中，可以换一种方式，传递一个参数即可：

public Integer compareByWeight(Animal another) {
    return this.getWeight() - another.getWeight();
}

调用代码如下：

animalList.sort(Animal::compareByWeight);

这里很多人都会疑惑，方法引用的前提，不都是入参个数都要一样吗？但 compareByWeight(Animal another) 方法只有一个参数，而 sort()  方法的形参  Comparator<T> 对应的抽象方法  compare(T o1, T o2) 是两个参数：

default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
}

这就是“类的任意对象的引用”这种类型的特殊之处。

方法引用会默认将第一个入参作为当前类的一个调用对象，其余参数继续作为方法的入参。

在本例中，compare(T o1, T o2) 方法是需要接入两个 Animal 对象的，但第一个对象 o1 可以作为当前 Animal 类的一个对象，剩下的 o2 继续作为引用方法  compareByWeight()  的参数，即：

o1.compareByWeight(o2)

这也是为何称为“类的任意对象的引用”。

为加深理解，我们再举一个例子。

前面的 Animal 类中，有一个 sleep()  普通方法和 bodyCheck(xx)  静态方法：

public class Animal {
    private String name;
    ...
    public void sleep() {
        System.out.println(this.getName() + " sleep.");
    }
    public static void bodyCheck(Animal animal) {
        System.out.println("body check " + animal.getName());
    }
}

Animal::sleep  构成了“类的任意对象的引用”，Animal::bodyCheck  构成了“静态方法引用”，它们都可以用在如下表达式中：

animalList.forEach(Animal::sleep);
animalList.forEach(Animal::bodyCheck);

sleep() 方法虽然没有入参，但依然可以用在 forEach() 方法中，因为  Consumer<T>  接口的 accept(T t) 抽象方法有一个入参，而该入参就可以作为 Animal 类的一个对象，来调用 sleep() 方法。

四、总结

如上所述，方法引用有多种类型，在实际使用过程中，可灵活运用。

说到底，跟 Lambda 表达式一样，它还是一种语法糖，为我们的开发工作提效。为达到同样的目标，相比传统实现方式，这种语法糖减轻了代码量，使用更轻便，不再拘泥于特定场景下囿于面向对象语言规则而产生的笨重表达，是对它们的一种轻量级替代。