方法引用(Method References)

2016年的 OneNote 笔记迁移到 博客园

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！

2、方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式， 也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。

3、要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！

4、格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。 5、如下三种主要使用情况：

• 对象::实例方法名
•     类::静态方法名
•     类::实例方法名

对象 ：： 实例方法名

如：

System.out

println（引用的方法）
    public void accept(String t) {
    //方法体不关心
｝

@Test
public void test1() {
　　Consumer<String> consumer1 = new Consumer<String>() 
　　　　@Override
　　　　public void accept(String t) {
　　　　　　System.out.println(t);
　　　　}
　　};
 
// ---------------------------------lambda表达式------------------------------
　　 
Consumer<String> consumer2 = t -> System.out.println(t);
// ---------------------------------方法的引用------------------------------
 
Consumer<String> consumer3 = System.out::println;

consumer3.accept("这里能打印输出");
}

解析：

public void accept(String t) {
    // 方法体不关心
｝
public void printlin(String t) {
　　// 方法体不关心
｝

两个方法，返回值一样，形参一样，所以可以直接引用 printlin()方法，实现功能

 

---

• 类/对象 ：：引用的方法名（引用的方法实现的方法必须是：返回值类型一样，形参列表一样，）

Consumer<String> consumer3 = System.out::println;
consumer3.accept("这里能打印输出");
 
PrintStream sout = System.out;
// sout(即：System.out)是对象
consumer3 = sout::println;

---

 

类::静态方法名（和第一个的区别是没区别，区别在于，对象可以调用方法，而静态方法只能用类调用）

@Test
public void test2() {
Function<Double, Long> f1 = new Function<Double, Long>() {
　　@Override
　　public Long apply(Double d) {
　　　　return Math.round(d);
　　}
};

// ---------------------------------lambda表达式-----------------------------
Function<Double, Long> f2 = d->Math.round(d);

// ---------------------------------方法的引用------------------------------
Function<Double, Long> f3 = Math::round;
}

解析：

public Long apply(Double d) {
    // 方法体不关心
}
 
public static Long round(Double d) {
   // 方法体不关心,方法静态不静态也不关心
}

---

 

类::实例方法名(类无法调用实例方法（加载时机不一致），所以默认为，第一参数作为方法的调用者，第二个参数作为实参)

/**
 * 类::实例方法名
 */
@Test
public void test3() {
　　Comparator<String> comparable1 = new Comparator<String>() {
　　　　@Override
　　　　public int compare(String o1, String o2) {
　　　　　　return o1.compareTo(o2);
　　　　}
};

// ---------------------------------lambda表达式------------------------------
Comparator<String> comparable2 = (o1,o2) -> o1.compareTo(o2);

// --------------方法的引用(类无法调用实例方法，所以用第一个参数调用方法)------------------------
Comparator<String> comparable3 = String::compareTo;

public int compare(String o1, String o2) {
　　return o1.compareTo(o2);
}
public int compareTo(String anotherString) {

}

Comparator<String> comparable3 = String::compareTo;

这个有点特殊，类无法调用实例方法（加载时机不一致），所以默认为，第一参数作为方法的调用者，第二个参数作为实参

 

 

 

/**
 * 1、当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！<br>
 * 2、方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，<br>
 * 也就是函数式接口的一个实例，通过方法的名字来指向一个方法，可以认为是Lambda表达式的一个语法糖。<br>
 * 3、要求：实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的方法的参数列表和返回值类型保持一致！<br>
 * 4、格式：使用操作符 “::” 将类(或对象) 与 方法名分隔开来。 5、如下三种主要使用情况：<br>
 *             对象::实例方法名 
 *             类::静态方法名 
 *             类::实例方法名
 */
public class MethodReferences {
 
　　/**
　　 * 对象::实例方法名
 　　*/
　　@Test
　　public void test1() {
　　　　Consumer<String> consumer1 = new Consumer<String>() {
　　　　@Override
　　　　public void accept(String t) {
　　　　　　// 方法体不关心
　　　　　　System.out.println(t);
　　　　}
　　};
 
　　Consumer<String> consumer2 = t -> System.out.println(t);
　　System.out.println("---------------进一步简化------------------");
 
　　Consumer<String> consumer3 = System.out::println;
　　consumer3.accept("这里能打印输出");
 
　　PrintStream sout = System.out;
　　// sout(即：System.out)是对象
　　consumer3 = sout::println;
　　}
 
　　/**
　　 * 类::静态方法名
　　 */
　　@Test
　　public void test2() {
 
　　　　Function<Double, Long> f1 = new Function<Double, Long>() {
　　　　　　@Override
　　　　　　public Long apply(Double d) {
　　　　　　　　// 方法体不关心
　　　　　　　　return Math.round(d);
　　　　　　}
　　　　};

　　　　// ---------------------------------lambda表达式------------------------------
　　　　Function<Double, Long> f2 = d -> Math.round(d);

　　　　// ---------------------------------方法的引用------------------------------
　　　　Function<Double, Long> f3 = Math::round;
　　}
 
　　/**
　　 * 类::实例方法名
　　 */
　　@Test
　　public void test3() {
　　　　Comparator<String> comparable1 = new Comparator<String>() {
　　　　　　@Override
　　　　　　public int compare(String o1, String o2) {
　　　　　　　　return o1.compareTo(o2);
　　　　　　}
　　　　};
　　　　// ---------------------------------lambda表达式------------------------------
　　　　Comparator<String> comparable2 = (o1,o2) -> o1.compareTo(o2);
　　　　// ---------------------------------方法的引用------------------------------
　　　　Comparator<String> comparable3 = String::compareTo;
　　}
}