java 8 java demo_Java8之方法引用

最新推荐文章于 2024-07-27 10:45:22 发布

金陵小老头

最新推荐文章于 2024-07-27 10:45:22 发布

阅读量121

点赞数

文章标签： java 8 java demo

本文链接：https://blog.csdn.net/weixin_33327380/article/details/114886166

版权

原标题：Java8之方法引用

一、概述

在学习lambda表达式之后，我们通常使用lambda表达式来创建匿名方法。然而，有时候我们仅仅是调用了一个已存在的方法。如下：

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

在Java8中，我们可以直接通过方法引用来简写lambda表达式中已经存在的方法。

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

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

二、什么是方法引用

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

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

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

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

三、方法引用例子

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

packagecom.demo.model;

importjava.time.LocalDate;

publicclassPerson{

publicPerson(String name, LocalDate birthday){

this.name = name;

this.birthday = birthday;

}

String name;

LocalDate birthday;

publicLocalDate getBirthday(){

returnbirthday;

}

publicstaticintcompareByAge(Person a, Person b){

returna.birthday.compareTo(b.birthday);

}

@Override

publicString toString(){

returnthis.name;

}

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

原始写法，使用匿名类：

packagecom.demo;

importjava.time.LocalDate;

importjava.util.Arrays;

importjava.util.Comparator;

importorg.junit.Test;

importcom.demo.model.Person;

publicclasstestMethodReference{

@Test

publicvoidtest(){

Person[] pArr = newPerson[]{

newPerson( "003", LocalDate.of( 2016, 9, 1)),

newPerson( "001", LocalDate.of( 2016, 2, 1)),

newPerson( "002", LocalDate.of( 2016, 3, 1)),

newPerson( "004", LocalDate.of( 2016, 12, 1))};

// 使用匿名类

Arrays.sort(pArr, newComparator() {

@Override

publicintcompare(Person a, Person b){

returna.getBirthday().compareTo(b.getBirthday());

}

});

System.out.println(Arrays.asList(pArr));

}

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

public staticvoid sort(T[] a, Comparator c)

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

使用Lambda表达式，我们可以这样写：

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

@Test

publicvoidtest1(){

Person[] pArr = newPerson[]{

newPerson( "003", LocalDate.of( 2016, 9, 1)),

newPerson( "001", LocalDate.of( 2016, 2, 1)),

newPerson( "002", LocalDate.of( 2016, 3, 1)),

newPerson( "004", LocalDate.of( 2016, 12, 1))};

//使用lambda表达式

Arrays.sort(pArr, (Person a, Person b) -> {

returna.getBirthday().compareTo(b.getBirthday());

});

System.out.println(Arrays.asList(pArr));

}

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

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

@Test

publicvoidtest2(){

Person[] pArr = newPerson[]{

newPerson( "003", LocalDate.of( 2016, 9, 1)),

newPerson( "001", LocalDate.of( 2016, 2, 1)),

newPerson( "002", LocalDate.of( 2016, 3, 1)),

newPerson( "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

publicvoidtest3(){

Person[] pArr = newPerson[]{

newPerson( "003", LocalDate.of( 2016, 9, 1)),

newPerson( "001", LocalDate.of( 2016, 2, 1)),

newPerson( "002", LocalDate.of( 2016, 3, 1)),

newPerson( "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.compare方法，即(Person, Person)；

表达式体调用Person.compareByAge方法。

四、四种方法引用类型

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

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

类型

示例

引用静态方法

ContainingClass::staticMethodName

引用某个对象的实例方法

containingObject::instanceMethodName

引用某个类型的任意对象的实例方法

ContainingType::methodName

引用构造方法

ClassName::new

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

1、静态方法引用

组成语法格式：ClassName::staticMethodName

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

注意：

静态方法引用比较容易理解，和静态方法调用相比，只是把 . 换为 ::

在目标类型兼容的任何地方，都可以使用静态方法引用。

例子：

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

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

字符串反转的例子：

packagecom.demo;

/**

* 函数式接口

publicinterfaceStringFunc{

String func(String n);

}

packagecom.demo;

publicclassMyStringOps{

//静态方法：反转字符串

publicstaticString strReverse(String str){

String result = "";

for( inti = str.length() - 1; i >= 0; i--) {

result += str.charAt(i);

}

returnresult;

}

packagecom.demo;

publicclassMethodRefDemo{

publicstaticString stringOp(StringFunc sf, String s){

returnsf.func(s);

}

publicstaticvoidmain(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 addpower to Java

String reserved: avaJ ot rewop dda adbmal

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

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

packagecom.demo;

publicclassMyClass{

privateintval;

MyClass( intv) {

val = v;

}

publicintgetValue(){

returnval;

}

packagecom.demo;

importjava.util.ArrayList;

importjava.util.Collections;

publicclassUseMethodRef{

publicstaticintcompareMC(MyClass a, MyClass b){

returna.getValue() - b.getValue();

}

publicstaticvoidmain(String[] args){

ArrayList a1 = newArrayList();

a1.add( newMyClass( 1));

a1.add( newMyClass( 4));

a1.add( newMyClass( 2));

a1.add( newMyClass( 9));

a1.add( newMyClass( 3));

a1.add( newMyClass( 7));

//UseMethodRef::compareMC生成了抽象接口Comparator定义的compare()方法的实例。

MyClass maxValObj = Collections.max(a1, UseMethodRef::compareMC);

System.out.println( "Maximum value is: "+ maxValObj.getValue());

}

输出结果：

Maximum valueis: 9

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

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

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

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

组成语法格式：instanceReference::methodName

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

classComparisonProvider{

publicintcompareByName(Person a, Person b){

returna.getName().compareTo(b.getName());

}

publicintcompareByAge(Person a, Person b){

returna.getBirthday().compareTo(b.getBirthday());

}

ComparisonProvider myComparisonProvider = newComparisonProvider();

Arrays.sort(rosterAsArray, myComparisonProvider::compareByName);

例子：反转字符串

packagecom.demo;

/**

* 函数式接口

publicinterfaceStringFunc{

String func(String n);

}

packagecom.demo;

publicclassMyStringOps{

//普通方法：反转字符串

publicString strReverse1(String str){

String result = "";

for( inti = str.length() - 1; i >= 0; i--) {

result += str.charAt(i);

}

returnresult;

}

packagecom.demo;

publicclassMethodRefDemo2{

publicstaticString stringOp(StringFunc sf, String s){

returnsf.func(s);

}

publicstaticvoidmain(String[] args){

String inStr = "lambda add power to Java";

MyStringOps strOps = newMyStringOps(); //实例对象

//strOps::strReverse1 相当于实现了接口方法func()

String outStr = stringOp(strOps::strReverse1, inStr);

System.out.println( "Original string: "+ inStr);

System.out.println( "String reserved: "+ outStr);

}

输出结果：

Original string: lambda addpower 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的第一个参数会成为调用实例方法的对象。

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

packagecom.demo;

publicinterfaceMyFunc{

intfunc(T[] als, T v);

}

packagecom.demo;

publicclassMyArrayOps{

publicstatic intcountMatching(T[] vals, T v){

intcount = 0;

for( inti = 0; i < vals.length; i++) {

if(vals[i] == v) count++;

}

returncount;

}

packagecom.demo;

publicclassGenericMethodRefDemo{

publicstatic intmyOp(MyFunc f, T[] vals, T v){

returnf.func(vals, v);

}

publicstaticvoidmain(String[] args){

Integer[] vals = { 1, 2, 3, 4, 2, 3, 4, 4, 5};

String[] strs = { "One", "Two", "Three", "Two"};

intcount;

count=myOp(MyArrayOps::countMatching, vals, 4);

System.out.println( "vals contains "+count+ " 4s");

count=myOp(MyArrayOps::countMatching, strs, "Two");

System.out.println( "strs contains "+count+ " Twos");

}

输出结果：

valscontains 34s

strs contains 2Twos

分析：

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

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

3、任意对象(属于同一个类)的实例方法引用

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

String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda"};

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

4、构造方法引用

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

a.构造方法引用(也可以称作构造器引用)

组成语法格式：Class::new

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

例子：

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