函数式接口、方法引用
概念
函数式接口在Java中是指:有且仅有一个抽象方法的接口。
函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。
备注:“语法糖”是指使用更加方便,但是原理不变的代码语法。例如在遍历集合时使用的for-each语法,其实底层的实现原理仍然是迭代器,这便是“语法糖”。从应用层面来讲,Java中的Lambda可以被当做是匿名内部类的“语法糖”,但是二者在原理上是不同的。
格式
只要确保接口中有且仅有一个抽象方法即可:
修饰符 interface 接口名称 {public abstract 返回值类型 方法名称(可选参数信息);// 其他非抽象方法内容
}
由于接口当中抽象方法的public abstract
是可以省略的,所以定义一个函数式接口很简单:
public interface MyFunctionalInterface { void myMethod();
}
@FunctionalInterface注解
与@Override
注解的作用类似,Java 8中专门为函数式接口引入了一个新的注解:@FunctionalInterface
。该注解可用于一个接口的定义上:
@FunctionalInterface
public interface MyFunctionalInterface {void myMethod();
}
一旦使用该注解来定义接口,编译器将会强制检查该接口是否确实有且仅有一个抽象方法,否则将会报错。需要注意的是,即使不使用该注解,只要满足函数式接口的定义,这仍然是一个函数式接口,使用起来都一样。
问题:为什么要使用该接口来验证一个接口是否是函数式接口呢?
如果一个接口是函数式接口,可以使用Lambda来简化代码的开发。
自定义函数式接口
对于刚刚定义好的MyFunctionalInterface
函数式接口,典型使用场景就是作为方法的参数:
public class Demo09FunctionalInterface { // 使用自定义的函数式接口作为方法参数private static void doSomething(MyFunctionalInterface inter) {inter.myMethod(); // 调用自定义的函数式接口方法}public static void main(String[] args) {// 调用使用函数式接口的方法doSomething(() -> System.out.println("Lambda执行啦!"));}
}
自定义函数式接口(无参无返回)
请定义一个函数式接口Eatable
,内含抽象eat
方法,没有参数或返回值。使用该接口作为方法的参数,并进而通过Lambda来使用它。
函数式接口的定义:
@FunctionalInterface
public interface Eatable {void eat();
}
应用场景代码:
/*请定义一个函数式接口Eatable,内含抽象eat方法,没有参数或返回值。使用该接口作为方法的参数,并进而通过Lambda来使用它。*/
public class Demo01 {public static void main(String[] args) {//调用show方法show(new Eatable() {@Overridepublic void eat() {System.out.println("吃饭了。。。。");}});System.out.println("---------------------------");show(()->System.out.println("吃饭了。。。。"));}/*Eatable e = new Eatable() {@Overridepublic void eat() {System.out.println("吃饭了。。。。");}}----------------------------------------------Eatable e = ()->System.out.println("吃饭了。。。。")*/public static void show(Eatable e){e.eat();}
}
自定义函数式接口(有参有返回)
请定义一个函数式接口Sumable
,内含抽象sum
方法,可以将两个int数字相加返回int结果。使用该接口作为方法的参数,并进而通过Lambda来使用它。
函数式接口的定义:
@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);
}
}
方法引用
在使用Lambda表达式的时候,我们实际上传递进去的代码就是一种解决方案:拿什么参数做什么操作。那么考虑一种情况:如果我们在Lambda中所指定的操作方案,已经有地方存在相同方案,那是否还有必要再写重复逻辑?
冗余的Lambda场景
来看一个简单的函数式接口以应用Lambda表达式:
@FunctionalInterface
public interface Printable {//打印字符串strvoid print(String str);
}
在Printable
接口当中唯一的抽象方法print
接收一个字符串参数,目的就是为了打印显示它。那么通过Lambda来使用它的代码很简单:
public class Demo02 {public static void main(String[] args) {//调用自定义方法printString(new Printable() {@Overridepublic void print(String s) {System.out.println("s = " + s);}});System.out.println("==============================");printString(s -> System.out.println("s = " + s));}//自定义方法 Printable接口作为参数/*Printable pt = new Printable() {@Overridepublic 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(类型可推导,所以可省略)数据后,在控制台中输出它。
问题分析
这段代码的问题在于,对字符串进行控制台打印输出的操作方案,明明已经有了现成的实现,那就是System.out
对象中的println(String)
方法。既然Lambda希望做的事情就是调用println(String)
方法,那何必自己手动调用呢?
用方法引用改进代码
能否省去Lambda的语法格式(尽管它已经相当简洁)呢?只要“引用”过去就好了:
public class Demo02PrintRef {private static void printString(Printable data) {data.print("Hello, World!");}public static void main(String[] args) {printString(System.out::println); //这种写法被称为方法引用}
}
请注意其中的双冒号::
写法,这种写法被称为“方法引用”,而双冒号是一种新的语法。
方法引用符
双冒号::
为引用运算符,而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中,那么则可以通过双冒号来引用该方法作为Lambda的替代者。
语义分析
例如上例中,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() {@Overridepublic 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
使用方法引用前提:使用对象引用成员方法,要求必须有该对象。
对象名引用成员方法
假设有一个助理类Assistant
,其中含有成员方法dealFile
如下:
public class Assistant { public void dealFile(String file) {System.out.println("帮忙处理文件:" + file);}
}
请自定义一个函数式接口WorkHelper
,其中的抽象方法help
的预期行为与dealFile
方法一致,并定义一个方法使用该函数式接口作为参数。通过方法引用的形式,将助理对象中的help
方法作为Lambda的实现。
函数式接口可以定义为:
@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);
}
}
通过类名称引用静态方法
由于在java.lang.Math
类中已经存在了静态方法abs
,所以当我们需要通过Lambda来调用该方法时,有两种写法。首先是函数式接口:
@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表达式:`
n -> Math.abs(n)
`方法引用:
Math::abs
类名称引用静态方法
假设有一个StringUtils
字符串工具类,其中含有静态方法isBlank
如下:
public class StringUtils {//定义一个成员方法判断是否为空public static boolean isBlank(String s){//"".equals(s.trim()去掉两端空格之后判断是否是空字符串return s == null || "".equals(s.trim());}
}
请自定义一个函数式接口StringChecker
,其中的抽象方法checkBlank
的预期行为与isBlank
一致,并定义一个方法使用该函数式接口作为参数。通过方法引用的形式,将StringUtils
工具类中的isBlank
方法作为Lambda的实现。
函数式接口的定义可以为:
@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);}
}
通过super引用成员方法
如果存在继承关系,当Lambda中需要出现super调用时,也可以使用方法引用进行替代。首先是函数式接口:
@FunctionalInterface
public interface Greetable {void greet();
}
然后是父类Fu
的内容:
public class Fu {public void say() {System.out.println("Fu 。。。Hello!");}
}
最后是子类Zi
的内容,其中使用了Lambda的写法:
public class Zi extends Fu {@Overridepublic void say() {method(() -> super.say());}private void method(Greetable lambda) {lambda.greet();System.out.println("I'm a zi!");}
}
但是如果使用方法引用来调用父类中的say
方法会更好,例如另一个子类Zi2
:
public class Zi2 extends Fu {@Overridepublic void say() {method(super::say);}private void method(Greetable lambda) {lambda.greet();System.out.println("I'm a zi2!");}
}
在这个例子中,下面两种写法是等效的:
Lambda表达式:
() -> super.say()
方法引用:`
super::say
`
通过this引用成员方法
this代表当前对象,如果需要引用的方法就是当前类中的成员方法,那么可以使用“this::成员方法”的格式来使用方法引用。首先是简单的函数式接口:
@FunctionalInterface
public interface Richable {void buy();
}
下面是一个丈夫Husband
类:
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
类的构造方法引用
由于构造方法的名称与类名完全一样,并不固定。所以构造方法引用使用类名称::new
的格式表示。首先是一个简单的Person
类:
public class Person {//成员变量 private String name;//构造函数public Person(String name) {this.name = name;}public String getName() {return name;}
}
然后是用来创建Person
对象的函数式接口:
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
数组的构造器引用
数组也是Object
的子类对象,所以同样具有构造器,只是语法稍有不同。如果对应到Lambda的使用场景中时,需要一个函数式接口:
@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]
方法引用:`
int[]::new
`
转载于:https://www.cnblogs.com/xinruyi/p/11030180.html
函数式接口、方法引用相关推荐
- lambda函数式接口方法引用Sream
Lambda表达式的使用 (o1, o2) -> Integer.compare(o1, o2); 格式: ->:lambda操作符或箭头操作符 ->左边:lambda形参列表(即接 ...
- Java笔记整理七(网络编程,TCP通信程序,函数式接口,方法引用)
网络编程入门 1.软件结构 C/S结构 :全称为Client/Server结构,是指客户端和服务器结构.常见程序有QQ.迅雷等软件. B/S结构 :全称为Browser/Server结构,是指浏览器和 ...
- Java高级:新特性:lambda 函数式接口 方法引用 StreamAPI Optional类
package com.atguigu.java1;import org.junit.Test;import java.util.Comparator;/*** Lambda表达式使用举例:** @a ...
- 函数式编程-Stream流/lambda表达式/Optional/函数式接口/方法引用/高级用法
函数式编程-Stream流 不会Lambda表达式.函数式编程?你确定能看懂公司代码?-java8函数式编程(Lambda表达式,Optional,Stream流)从入门到精通-最通俗易懂 1. 概述 ...
- Java函数式实现替代策略模式解决 if...else代码,Map+函数式接口方法
之前记录过用自定义注解和策略模式实现发不同消息的功能笔记: 文章地址:发送不同类型的消息----------策略模式_不受天磨非好汉,不遭人妒是庸才--着实着迷゛-CSDN博客r一:首先看下代码结构a ...
- 解决if-else的另一种姿势:Map + 函数式接口方法!
本文介绍策略模式的具体应用以及Map+函数式接口如何 "更完美" 的解决 if-else的问题. 需求 最近写了一个服务:根据优惠券的类型resourceType和编码resour ...
- java函数接口和方法引用
目录 四大核心函数式接口 自定义函数式接口 方法引用 对象::实例方法 类::静态方法名字 类::实例方法名字 构造器引用 class::new 数组引用 数组::new 四大核心函数式接口 概念:有 ...
- 函数式接口 lambda表达式 方法引用
拉呱: 终于,学习jdk8的新特性了,初体验带给我的感觉真爽,代码精简的不行,可读性也很好,而且,spring5也是把jdk8的融入到血液里,总之一句话吧,说的打趣一点,学的时候自己难受,学完了写出来 ...
- Java Lambda(语言篇——lambda,方法引用,目标类型,默认方法,函数接口,变量捕获)
深入理解Java 8 Lambda(语言篇--lambda,方法引用,目标类型和默认方法) 原文链接:http://zh.lucida.me/blog/java-8-lambdas-insideout ...
最新文章
- 创建数据库,指定数据库的字符集和编码顺序
- 微信小程序之apply和call ( 附示例代码和注释讲解) apply call bind
- 腾讯云发布智慧能源四大新品,携手合作伙伴共建智慧能源生态圈
- 36.centos 安装文泉驿字体
- vs2015 支持Android arm neon Introducing Visual Studio’s Emulator for Android
- c语言循环数组赋值,for循环里边给数组赋值的难题
- matlab编程 英文翻译,MATLAB编程,MATLAB programming,音标,读音,翻译,英文例句,英语词典...
- nexttick使用场景_使用Jest实现Vue自动化测试
- 【实践】小红书推荐中台实践
- SQL Sever 常用语句总结
- 笨方法学习python--46--python项目骨架
- Eclipse创建带JavaBean的JSP程序
- 检测到您尚未安装ALEXA工具条
- fins协议握手信号服务器响应,欧姆龙OMRON PLC之HostLink通讯协议(四)-FINS命令工作模式篇...
- 中国雅虎邮箱一键迁移到网易邮箱教程
- dubbo admin安装中易踩坑点及解决方法
- 阿里天池数据分析入门 利用Pandas分析数据
- php 拼接html字符串,php截断带html字符串文章内容的方法
- 实战 | 如何使用微搭低代码实现按条件过滤数据
- 视觉SLAM十四讲读书笔记(2)P10-P27
热门文章
- python列表元素赋值_如何在python中的列表列表的所有元素上执行“一行”赋值
- html表格判断,lua table 长度解析
- java tcp read_【Java TCP/IP Socket】TCP Socket通信中由read返回值造成的的死锁问题(含代码)(转)...
- mysql表创建在哪_mysql创建表命令是哪句
- 机器学习(MACHINE LEARNING)从零搭建一个汽车状态分类器(Tensorflow)
- linux c++开发环境_使用 VM VirtualBox 搭建完善的Linux开发环境
- lay和lied_lie和lay的区别和用法是什么
- Error: Cannot find module ‘webpack-cli/bin/config-yargs‘
- css设置鼠标指针光标样式
- frp 内网穿透, 认证配置,安全配置 TOKEN