函数式接口方法引用
Posted xinruyi
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了函数式接口方法引用相关的知识,希望对你有一定的参考价值。
函数式接口在Java中是指:有且仅有一个抽象方法的接口。
函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。
修饰符 interface 接口名称 public abstract 返回值类型 方法名称(可选参数信息); // 其他非抽象方法内容
public interface MyFunctionalInterface void myMethod();
@FunctionalInterface public interface MyFunctionalInterface void myMethod();
一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。需要注意的是,即使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。
问题:为什么要使用该接口来验证一个接口是否是函数式接口呢?
如果一个接口是函数式接口,可以使用Lambda来简化代码的开发。
public class Demo09FunctionalInterface // 使用自定义的函数式接口作为方法参数 private static void doSomething(MyFunctionalInterface inter) inter.myMethod(); // 调用自定义的函数式接口方法 public static void main(String[] args) // 调用使用函数式接口的方法 doSomething(() -> System.out.println("Lambda执行啦!"));
函数式接口的定义:
@FunctionalInterface public interface Eatable void eat();
应用场景代码:
/* 请定义一个函数式接口Eatable,内含抽象eat方法, 没有参数或返回值。使用该接口作为方法的参数,并进而通过Lambda来使用它。 */ public class Demo01 public static void main(String[] args) //调用show方法 show(new Eatable() @Override public void eat() System.out.println("吃饭了。。。。"); ); System.out.println("---------------------------"); show(()->System.out.println("吃饭了。。。。")); /* Eatable e = new Eatable() @Override public void eat() System.out.println("吃饭了。。。。"); ---------------------------------------------- Eatable e = ()->System.out.println("吃饭了。。。。") */ public static void show(Eatable e) e.eat();
函数式接口的定义:
@FunctionalInterface public interface Sumable int sum(int a, int b);
应用场景代码:
/* 请定义一个函数式接口Sumable,内含抽象sum方法, 可以将两个int数字相加返回int结果。使用该接口作为方法的参数,并进而通过Lambda来使用它。 */ public class Demo01 public static void main(String[] args) //调用方法求两个数的和值 sumInt(3, 4, new Sumable() @Override public int sum(int i, int j) return i+j; ); System.out.println("-----------------------"); sumInt(3,4,(int i,int j)->i+j);//这里完成sum方法体的内容 //定义方法求两个数的和值 /* int x=3 int y=4 Sumable lambda = new Sumable() @Override public int sum(int i, int j) return i+j; int x=3 int y=4 Sumable lambda = (int i,int j)->i+j */ public static void sumInt(int x,int y,Sumable lambda) int sum = lambda.sum(x, y); System.out.println("sum = " + sum);
@FunctionalInterface public interface Printable //打印字符串str void print(String str);
public class Demo02 public static void main(String[] args) //调用自定义方法 printString(new Printable() @Override public void print(String s) System.out.println("s = " + s); ); System.out.println("=============================="); printString(s -> System.out.println("s = " + s)); //自定义方法 Printable接口作为参数 /* Printable pt = new Printable() @Override public void print(String s) System.out.println("s = " + s); */ public static void printString(Printable pt) //传递参数 pt.print("Hello 上海");
其中在printString
方法中只管调用Printable
接口的print
方法,而并不管print
方法的具体实现逻辑会将字符串打印到什么地方去。而main
方法通过Lambda表达式指定了函数式接口Printable
的具体操作方案为:拿到String(类型可推导,所以可省略)数据后,在控制台中输出它。
public class Demo02PrintRef private static void printString(Printable data) data.print("Hello, World!"); public static void main(String[] args) printString(System.out::println); //这种写法被称为方法引用
请注意其中的双冒号::
写法,这种写法被称为“方法引用”,而双冒号是一种新的语法。
例如上例中,System.out
对象中有一个重载的println(String)
方法恰好就是我们所需要的。那么对于printString
方法的函数式接口参数,对比下面两种写法,完全等效:
-
Lambda表达式写法:
s -> System.out.println(s);
-
方法引用写法:
System.out::println
第一种语义是指:拿到参数之后经Lambda之手,继而传递给System.out.println
方法去处理。
第二种等效写法的语义是指:直接让System.out
中的println
方法来取代Lambda。两种写法的执行效果完全一样,而第二种方法引用的写法复用了已有方案,更加简洁。
推导与省略
如果使用Lambda,那么根据“可推导就是可省略”的原则,无需指定参数类型,也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用,也是同样可以根据上下文进行推导。
函数式接口是Lambda的基础,而方法引用是Lambda的孪生兄弟。就是只要可以使用Lambda的地方都可以使用方法引用,没有使用Lambda表达式就不能使用方法引用。
下面这段代码将会调用println
方法的不同重载形式,将函数式接口改为int类型的参数:
@FunctionalInterface public interface PrintableInteger void print(int str);
由于上下文变了之后可以自动推导出唯一对应的匹配重载,所以方法引用没有任何变化:
public class Demo03PrintOverload private static void printInteger(PrintableInteger data) data.print(1024); public static void main(String[] args) printInteger(System.out::println);
这次方法引用将会自动匹配到println(int)
这是最常见的一种用法,与上例相同。如果一个类中已经存在了一个成员方法:
在MethodRefObject类的方法printUpperCase中负责将参数str转换为大写。
public class MethodRefObject public void printUpperCase(String str) System.out.println(str.toUpperCase());
函数式接口仍然定义为:
@FunctionalInterface public interface Printable void print(String str);
那么当需要使用这个printUpperCase
成员方法来替代Printable
接口的Lambda的时候,已经具有了MethodRefObject
类的对象实例,则可以通过对象名引用成员方法,代码为:
Lambda表达式格式:(参数) -> 对象.方法名(参数)
方法引用格式: 对象::方法名
/* Lambda表达式格式:(参数) -> 对象.方法名(参数) 方法引用格式: 对象::方法名 */ public class MethodRefTest public static void main(String[] args) //创建对象 MethodRefObject methodRefObject = new MethodRefObject(); System.out.println("--------------匿名内部类形式---------------"); //调用自定义方法将指定的字符串变为大写 show("suoge", new Printable() @Override public void print(String str) //使用methodRefObject对象调用方法 methodRefObject.printUpperCase(str); ); System.out.println("--------------Lambda表达式形式---------------"); //调用自定义方法将指定的字符串变为大写 /*show("suoge",(String s2) -> //使用methodRefObject对象调用方法 methodRefObject.printUpperCase(s2); );*/ //Lambda省略和推到形式 show("suoge", s2 -> methodRefObject.printUpperCase(s2)); System.out.println("--------------方法引用形式---------------"); //调用自定义方法将指定的字符串变为大写 /* Lambda表达式格式:(参数) -> 对象.方法名(参数) 方法引用格式: 对象::方法名 */ show("suoge", methodRefObject::printUpperCase); //自定义方法 public static void show(String s, Printable pt) //调用Printable接口中的方法将s变为大写 pt.print(s);
在这个例子中,下面两种写法是等效的:
-
Lambda表达式:
s2 -> methodRefObject.printUpperCase(s2)
-
方法引用:
methodRefObject::printUpperCase
使用方法引用前提:使用对象引用成员方法,要求必须有该对象。
public class Assistant public void dealFile(String file) System.out.println("帮忙处理文件:" + file);
请自定义一个函数式接口WorkHelper
,其中的抽象方法help
的预期行为与dealFile
方法一致,并定义一个方法使用该函数式接口作为参数。通过方法引用的形式,将助理对象中的help
函数式接口可以定义为:
@FunctionalInterface public interface WorkHelper void help(String file);
通过对象名引用成员方法的使用场景代码为:
public class DemoAssistant
private static void work(WorkHelper helper)
helper.help("机密文件");
public static void main(String[] args)
Assistant assistant = new Assistant();
work(assistant::dealFile);
@FunctionalInterface public interface Calcable int calc(int num);
第一种写法是使用Lambda表达式:
public class Demo05Lambda private static void method(int num, Calcable lambda) int x = lambda.calc(num); System.out.println(x); public static void main(String[] args) method(-10, n -> Math.abs(n));
但是使用方法引用的更好写法是:
public class Demo06MethodRef private static void method(int num, Calcable lambda) int x = lambda.calc(num); System.out.println(x); public static void main(String[] args) method(-10, Math::abs);
在这个例子中,下面两种写法是等效的:
-
Lambda表达式:
-
方法引用:
Math::abs
public class StringUtils //定义一个成员方法判断是否为空 public static boolean isBlank(String s) //"".equals(s.trim()去掉两端空格之后判断是否是空字符串 return s == null || "".equals(s.trim());
函数式接口的定义可以为:
@FunctionalInterface public interface StringChecker boolean checkString(String str);
应用场景代码为:
public class Demo public static void main(String[] args) //调用自定义方法 /*methodCheck(" haha ",(s1)-> return StringUtils.isBlank(s1); );*/ //推到省略格式 // methodCheck(" ",s1->StringUtils.isBlank(s1)); //方法引用格式 methodCheck(" ",StringUtils::isBlank); //定义自定义方法 public static void methodCheck(String s,StringChecker stringChecker) boolean boo = stringChecker.checkString(s); System.out.println("boo = " + boo);
@FunctionalInterface public interface Greetable void greet();
public class Fu public void say() System.out.println("Fu 。。。Hello!");
public class Zi extends Fu @Override public void say() method(() -> super.say()); private void method(Greetable lambda) lambda.greet(); System.out.println("I‘m a zi!");
public class Zi2 extends Fu @Override public void say() method(super::say); private void method(Greetable lambda) lambda.greet(); System.out.println("I‘m a zi2!");
在这个例子中,下面两种写法是等效的:
-
Lambda表达式:
() -> super.say()
-
方法引用:
@FunctionalInterface public interface Richable void buy();
public class Husband public void beHappy() marry(()-> System.out.println("买套房子")); private void marry(Richable richable) richable.buy();
开心方法beHappy
调用了结婚方法marry
,后者的参数为函数式接口Richable
,所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了,则可以对Husband
public class Husband_1 private void buyHouse() System.out.println("买套房子"); public void beHappy() marry(()->this.buyHouse()); private void marry(Richable richable) richable.buy();
如果希望取消掉Lambda表达式,用方法引用进行替换,则更好的写法为:
public class Husband_1 private void buyHouse() System.out.println("买套房子"); public void beHappy() marry(this::buyHouse); private void marry(Richable richable) richable.buy();
在这个例子中,下面两种写法是等效的:
-
Lambda表达式:
() -> this.buyHouse()
-
方法引用:
this::buyHouse
public class Person //成员变量 private String name; //构造函数 public Person(String name) this.name = name; public String getName() return name;
public interface PersonBuilder Person buildPerson(String name);
要使用这个函数式接口,可以通过Lambda表达式:
public class Demo09Lambda public static void main(String[] args) printName("赵丽颖",(String name)->return new Person(name);); private static void printName(String name,PersonBuilder builder) Person p = builder.buildPerson(name); //这一行代码中的builder哪里来的? System.out.println(p.getName());
但是通过构造方法引用,有更好的写法:
public class Demo10ConstructorRef public static void printName(String name, PersonBuilder builder) Person p=builder.buildPerson(name); System.out.println(p.getName()); public static void main(String[] args) printName("赵丽颖", Person::new);
在这个例子中,下面两种写法是等效的:
-
Lambda表达式:
name -> new Person(name)
-
方法引用:
Person::new
@FunctionalInterface public interface ArrayBuilder int[] buildArray(int length);//length表示数组的长度
在应用该接口的时候,可以通过Lambda表达式:
public class Demo11ArrayInitRef private static int[] initArray(int length, ArrayBuilder builder) return builder.buildArray(length); public static void main(String[] args) //int[] array = initArray(10, (length) ->return new int[length];); int[] array = initArray(10, length -> new int[length]);
但是更好的写法是使用数组的构造器引用:
public class Demo12ArrayInitRef
private static int[] initArray(int length, ArrayBuilder builder)
return builder.buildArray(length);
public static void main(String[] args)
int[] array = initArray(10, int[]::new); //方法引用
在这个例子中,下面两种写法是等效的:
-
Lambda表达式:
length -> new int[length]
-
方法引用:
以上是关于函数式接口方法引用的主要内容,如果未能解决你的问题,请参考以下文章