Java8之方法引用

时间  2019-11-13
标签 java8 java 方法 引用 栏目 Java 繁體版
原文   原文链接

1、概述java

在学习lambda表达式以后，咱们一般使用lambda表达式来建立匿名方法。然而，有时候咱们仅仅是调用了一个已存在的方法。以下：数组

Arrays.sort(stringsArray,(s1,s2)->s1.compareToIgnoreCase(s2));

 在Java8中，咱们能够直接经过方法引用来简写lambda表达式中已经存在的方法。app

Arrays.sort(stringsArray, String::compareToIgnoreCase);

这种特性就叫作方法引用(Method Reference)。ide

2、什么是方法引用函数

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

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

注意方法引用是一个Lambda表达式，其中方法引用的操做符是双冒号"::"。spa

============================================================================指针

      简单地说，就是一个Lambda表达式。在Java 8中，咱们会使用Lambda表达式建立匿名方法，可是有时候，咱们的Lambda表达式可能仅仅调用一个已存在的方法，而不作任何其它事，对于这种状况，经过一个方法名字来引用这个已存在的方法会更加清晰，Java 8的方法引用容许咱们这样作。方法引用是一个更加紧凑，易读的Lambda表达式，注意方法引用是一个Lambda表达式，其中方法引用的操做符是双冒号"::"。code

3、方法引用例子

先看一个例子，首先定义一个Person类，以下：

package com.demo.model;

import java.time.LocalDate;

public class Person {

    public Person(String name, LocalDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    String name;
    LocalDate birthday;

    public LocalDate getBirthday() {
        return birthday;
    }

    public static int compareByAge(Person a, Person b) {
        return a.birthday.compareTo(b.birthday);
    }

    @Override
    public String toString() {
        return this.name;
    }
}

假设咱们有一个Person数组，而且想对它进行排序，这时候，咱们可能会这样写：

原始写法，使用匿名类：

package com.demo;

import java.time.LocalDate;
import java.util.Arrays;
import java.util.Comparator;
import org.junit.Test;
import com.demo.model.Person;

public class testMethodReference {

    @Test
    public void test() {
        Person[] pArr = new Person[]{
                new Person("003", LocalDate.of(2016,9,1)),
                new Person("001", LocalDate.of(2016,2,1)),
                new Person("002", LocalDate.of(2016,3,1)),
                new Person("004", LocalDate.of(2016,12,1))};

        // 使用匿名类
        Arrays.sort(pArr, new Comparator<Person>() {
            @Override
            public int compare(Person a, Person b) {
                return a.getBirthday().compareTo(b.getBirthday());
            }
        });
        
        System.out.println(Arrays.asList(pArr));
    }
}

其中，Arrays类的sort方法定义以下：

public static <T> void sort(T[] a, Comparator<? super T> c)

这里，咱们首先要注意Comparator接口是一个函数式接口，所以咱们可使用Lambda表达式，而不须要定义一个实现Comparator接口的类，并建立它的实例对象，传给sort方法。

使用Lambda表达式，咱们能够这样写：

改进一，使用Lambda表达式，未调用已存在的方法

@Test
public void test1() {
    Person[] pArr = new Person[]{
            new Person("003", LocalDate.of(2016,9,1)),
            new Person("001", LocalDate.of(2016,2,1)),
            new Person("002", LocalDate.of(2016,3,1)),
            new Person("004", LocalDate.of(2016,12,1))};
    
    //使用lambda表达式
    Arrays.sort(pArr, (Person a, Person b) -> {
        return a.getBirthday().compareTo(b.getBirthday());
    });
    
    System.out.println(Arrays.asList(pArr));
}

然而，在以上代码中，关于两我的生日的比较方法在Person类中已经定义了，所以，咱们能够直接使用已存在的Person.compareByAge方法。

改进二，使用Lambda表达式，调用已存在的方法

@Test
public void test2() {
    Person[] pArr = new Person[]{
            new Person("003", LocalDate.of(2016,9,1)),
            new Person("001", LocalDate.of(2016,2,1)),
            new Person("002", LocalDate.of(2016,3,1)),
            new Person("004", LocalDate.of(2016,12,1))};
    
    //使用lambda表达式和类的静态方法
    Arrays.sort(pArr, (a ,b) -> Person.compareByAge(a, b));
    
    System.out.println(Arrays.asList(pArr));
}

由于这个Lambda表达式调用了一个已存在的方法，所以，咱们能够直接使用方法引用来替代这个Lambda表达式。

改进三，使用方法引用

@Test
public void test3() {
    Person[] pArr = new Person[]{
            new Person("003", LocalDate.of(2016,9,1)),
            new Person("001", LocalDate.of(2016,2,1)),
            new Person("002", LocalDate.of(2016,3,1)),
            new Person("004", LocalDate.of(2016,12,1))};
    
    //使用方法引用，引用的是类的静态方法
    Arrays.sort(pArr, Person::compareByAge);
    
    System.out.println(Arrays.asList(pArr));
}

运行结果：

[001, 002, 003, 004]

在以上代码中，方法引用Person::compareByAge在语义上与Lambda表达式 (a, b) -> Person.compareByAge(a, b) 是等同的，都有以下特性：

  • 真实的参数是拷贝自Comparator<Person>.compare方法，即(Person, Person)；
  • 表达式体调用Person.compareByAge方法。

4、四种方法引用类型

方法引用的标准形式是：类名::方法名。（注意：只须要写方法名，不须要写括号）

有如下四种形式的方法引用：

类型 示例
引用静态方法 ContainingClass::staticMethodName
引用某个对象的实例方法 containingObject::instanceMethodName
引用某个类型的任意对象的实例方法 ContainingType::methodName
引用构造方法 ClassName::new

 

 

 

 

 

 

下面咱们经过一个小Demo来分别学习这几种形式的方法引用：

一、静态方法引用

组成语法格式：ClassName::staticMethodName

咱们前面举的例子Person::compareByAge就是一个静态方法引用。

注意：

  • 静态方法引用比较容易理解，和静态方法调用相比，只是把 . 换为 ::
  • 在目标类型兼容的任何地方，均可以使用静态方法引用。

例子：

　　String::valueOf   等价于lambda表达式 (s) -> String.valueOf(s)

　　Math::pow       等价于lambda表达式  (x, y) -> Math.pow(x, y);

字符串反转的例子：

package com.demo;

/**
 * 函数式接口
 */
public interface StringFunc {
    
    String func(String n);
}
package com.demo;

public class MyStringOps {
    
    //静态方法： 反转字符串
    public static String strReverse(String str) {
        String result = "";
        for (int i = str.length() - 1; i >= 0; i--) {
            result += str.charAt(i);
        }
        return result;
    }

}
package com.demo;

public class MethodRefDemo {
    
    public static String stringOp(StringFunc sf, String s) {
        return sf.func(s);
    }
    
    public static void main(String[] args) {
        String inStr = "lambda add power to Java";
        //MyStringOps::strReverse 至关于实现了接口方法func() 
        // 并在接口方法func()中做了MyStringOps.strReverse()操做
         String outStr = stringOp(MyStringOps::strReverse, inStr);
        System.out.println("Original string: " + inStr);
        System.out.println("String reserved: " + outStr);
    }

}

输出结果：

Original string: lambda add power to Java
String reserved: avaJ ot rewop dda adbmal

表达式MyStringOps::strReverse的计算结果为对象引用，其中，strReverse提供了StringFunc的func()方法的实现。

找到列表中具备最大值的对象

package com.demo;

public class MyClass {

    private int val;

    MyClass(int v) {
        val = v;
    }
    
    public int getValue() {
        return val;
    }

}
package com.demo;

import java.util.ArrayList;
import java.util.Collections;

public class UseMethodRef {
    
     public static int compareMC(MyClass a, MyClass b) {
         return a.getValue() - b.getValue();
     }
     
     public static void main(String[] args) {
         ArrayList<MyClass> a1 = new ArrayList<MyClass>();
         a1.add(new MyClass(1));
         a1.add(new MyClass(4));
         a1.add(new MyClass(2));
         a1.add(new MyClass(9));
         a1.add(new MyClass(3));
         a1.add(new MyClass(7));
         //UseMethodRef::compareMC生成了抽象接口Comparator定义的compare()方法的实例。
         MyClass maxValObj = Collections.max(a1, UseMethodRef::compareMC);
         System.out.println("Maximum value is: " + maxValObj.getValue());
    }

}

输出结果：

Maximum value is: 9

UseMethodRef定义了静态方法compareMC()，它与Comparator定义的compare()方法兼容。所以，没有必要显式的实现Comparator接口并建立其实例。

二、特定实例对象的方法引用

这种语法与用于静态方法的语法相似，只不过这里使用对象引用而不是类名。实例方法引用又分如下三种类型：

a.实例上的实例方法引用

组成语法格式：instanceReference::methodName

以下示例，引用的方法是myComparisonProvider 对象的compareByName方法。

class ComparisonProvider{
    
    public int compareByName(Person a, Person b){
        return a.getName().compareTo(b.getName());
    }

    public int compareByAge(Person a, Person b){
        return a.getBirthday().compareTo(b.getBirthday());
    }
}

ComparisonProvider myComparisonProvider = new ComparisonProvider();
Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);

例子：反转字符串

package com.demo;

/**
 * 函数式接口
 */
public interface StringFunc {
    
    String func(String n);
}
package com.demo;

public class MyStringOps {
    
    //普通方法： 反转字符串
    public String strReverse1(String str) {
        String result = "";
        for (int i = str.length() - 1; i >= 0; i--) {
            result += str.charAt(i);
        }
        return result;
    }

}
package com.demo;

public class MethodRefDemo2 {

    public static String stringOp(StringFunc sf, String s) {
        return sf.func(s);
    }
    
    public static void main(String[] args) {
        String inStr = "lambda add power to Java";
        MyStringOps strOps = new MyStringOps();//实例对象
        //strOps::strReverse1 至关于实现了接口方法func() 
        String outStr = stringOp(strOps::strReverse1, inStr);

        System.out.println("Original string: " + inStr);
        System.out.println("String reserved: " + outStr);
    }

}

输出结果：

Original string: lambda add power to Java
String reserved: avaJ ot rewop dda adbmal

b.超类上的实例方法引用

组成语法格式：super::methodName

方法的名称由methodName指定，经过使用super，能够引用方法的超类版本。

例子：

还能够捕获this 指针，this :: equals  等价于lambda表达式  x -> this.equals(x);

c.类型上的实例方法引用

组成语法格式：ClassName::methodName

注意：

若类型的实例方法是泛型的，就须要在::分隔符前提供类型参数，或者（多数状况下）利用目标类型推导出其类型。

静态方法引用和类型上的实例方法引用拥有同样的语法。编译器会根据实际状况作出决定。通常咱们不须要指定方法引用中的参数类型，由于编译器每每能够推导出结果，但若是须要咱们也能够显式在::分隔符以前提供参数类型信息。

例子：

String::toString 等价于lambda表达式 (s) -> s.toString()

这里不太容易理解，实例方法要经过对象来调用，方法引用对应Lambda，Lambda的第一个参数会成为调用实例方法的对象。

在泛型类或泛型方法中，也可使用方法引用。

package com.demo;

public interface MyFunc<T> {
    
    int func(T[] als, T v);
}
package com.demo;

public class MyArrayOps {

     public static <T> int countMatching(T[] vals, T v) {
         int count = 0;
         for (int i = 0; i < vals.length; i++) {
             if (vals[i] == v) count++;
         }
         return count;
     }

}
package com.demo;

public class GenericMethodRefDemo {
    
    public static <T> int myOp(MyFunc<T> f, T[] vals, T v) {
        return f.func(vals, v);
    }
    
    public static void main(String[] args){
        Integer[] vals = {1, 2, 3, 4, 2, 3, 4, 4, 5};
        String[] strs = {"One", "Two", "Three", "Two"};
        int count;
        count=myOp(MyArrayOps::<Integer>countMatching, vals, 4);
        System.out.println("vals contains "+count+" 4s");
        count=myOp(MyArrayOps::<String>countMatching, strs, "Two");
        System.out.println("strs contains "+count+" Twos");
    }

}

输出结果：

vals contains 3 4s
strs contains 2 Twos

分析：

      在程序中，MyArrayOps是非泛型类，包含泛型方法countMatching()。该方法返回数组中与指定值匹配的元素的个数。注意这里如何指定泛型类型参数。例如，在main()方法中，对countMatching()方法的第一次调用以下所示：count = myOp(MyArrayOps::<Integer>countMatching,vals,4); 这里传递了类型参数Integer。

      注意，参数传递发生在::的后面。这种语法能够推广。当把泛型方法指定为方法引用时，类型参数出如今::以后、方法名以前。可是，须要指出的是，在这种状况(和其它许多状况)下，并不是必须显示指定类型参数，由于类型参数会被自动推断得出。对于指定泛型类的状况，类型参数位于类名的后面::的前面。

三、任意对象（属于同一个类）的实例方法引用

以下示例，这里引用的是字符串数组中任意一个对象的compareToIgnoreCase方法。

String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" };
Arrays.sort(stringArray, String::compareToIgnoreCase);

四、构造方法引用

构造方法引用又分构造方法引用和数组构造方法引用。

a.构造方法引用（也能够称做构造器引用）

组成语法格式：Class::new

构造函数本质上是静态方法，只是方法名字比较特殊，使用的是new 关键字。

例子：

String::new， 等价于lambda表达式 () -> new String() 

package com.demo;

public interface MyFunc1 {

    MyClass func(int n);

}
package com.demo;

public class MyClass {

    private int val;

    MyClass(int v) {
        val = v;
    }
    
    MyClass(){
        val = 0;
    }
    
    public int getValue() {
        return val;
    }

}
package com.demo;

public class ConstructorRefDemo {

    public static void main(String[] args) {
        MyFunc1 myClassCons = MyClass :: new;
        MyClass mc = myClassCons.func(100);
        System.out.println("val in mc is: " + mc.getValue());
    }
}

输出结果：

val in mc is: 100

b.数组构造方法引用

组成语法格式：TypeName[]::new

例子：

int[]::new 是一个含有一个参数的构造器引用，这个参数就是数组的长度。等价于lambda表达式  x -> new int[x]。

假想存在一个接收int参数的数组构造方法

IntFunction<int[]> arrayMaker = int[]::new;
int[] array = arrayMaker.apply(10) // 建立数组 int[10]
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程