Lambda 表达式
2018-12-02 06:17:21来源:博客园 阅读 ()
简介
相传,在远古时代,有一位逻辑学家某某,想要形式化的表示能有效计算的数学函数,由于别的书中使用重音符^来表示自由变量,某某受此启发,使用大写的lambda(∧)表示参数,后来又改成了小写的lambda(λ),从此以后,带参数变量的表达式就被称为lambda表达式,读音:lan b(m)da (兰亩达)。
到了2015年,lambda表达式加入了JDK8,它显著的增强了Java,在最近几年中,lambda表达式已经成为了计算机语言设计的重点关注对象,几年前的泛型重塑了Java,如今lambda表达式也正在重塑Java的编程风格。
简而言之:lambda表达式,无论如何,就算天崩地裂,得了绝症,也得学!
言归正传
lambda表达式本质上就是一个匿名方法,但是这个方法不是独立执行的,而是用于实现由函数式接口定义的另一个方法,因此lambda表达式会导致产生一个匿名类,也可以称之为闭包。
语法结构
lambda表达式在Java语言中引入了一个新的语法元素和操作符,这个操作符是->,有时候被称为lambda操作符或者箭头操作符,它将lambda表达式分成两个部分,左侧指定了lambda表达式需要的所有参数(不需要参数则使用空括号),右侧是表达式的主体。
下面看一个最简单的lambda表达式:
()-> 12;
这个lambda表达式没有参数,但是它有返回值,返回的是Int类型。
如果代码要完成的功能无法放在一个表达式中,就可以像写方法一样,把代码放在代码块中,用大括号包起来。
()->{ for(int i=0;i<10;i++){ System.out.println(i); } }
这个lambda没有返回值,也可以说它的返回值是void,如果有返回值的话,需要在表达式主体的最后使用return关键字返回指定类型的数据。
下面来看一个有参数的lambda表达式
(int n,int m)->n+m;
参数为int,返回值也是int类型。
不过一般来说我们这么写:
(n,m)->n+m;
如果只有一个入参,你甚至连括号都可以省:
n -> n+1;
省略了参数类型,因为参数类型是可以被自动推断出来的。
函数式接口
函数式接口是仅包含一个抽象方法的接口,可以反过来这么说,凡是只包含一个抽象方法的接口,都可以叫做函数式接口。
为什么要说函数式接口呢?因为lambda表达式的运行需要依赖函数式接口。
从JDK8开始,可以为接口的声明的方法指定默认行为,就是所谓的默认方法(在接口中用default关键字声明的方法,并且可以在接口中直接实现该方法,使得实现该接口的类不需要实现该方法,就如继承一样直接调用),因为该默认方法没有指定默认实现,所以它就是隐式的是抽象方法,没有必要使用abstract修饰符,当然,如果愿意的话,也可以加上abstract修饰符。
示例:
public interface Admin { String getName(); }
随便写的一个接口,只要这个接口中只有一个抽象方法,那么这就是一个函数式接口。(注意措辞:只有一个抽象方法,并不是只有一个方法,因为还可以存在默认方法)
lambda表达式允许你直接以内联的形式为函数式接口的抽象方法提供实现,也就是说,lambda表达式构成了一个函数式接口定义的抽象方法的实现,该函数式接口定义了它的目标类型。
下面示例lambda表达式的使用方法(使用到上面的Admin接口):
Admin admin = ()->"张三";
System.out.println(admin.getName());
打印结果为:张三
当目标类型上下文出现lambda表达式时,会自动创建实现了该函数式接口的一个类的实例,函数式接口声明的抽象方法的行为由lambda表达式定义,当通过目标调用该方法时,就会执行lambda表达式,因此,lambda表达式提供了一种将代码片段转换为对象的方法。
也就是说,也就是说,也就是说,重要的事情说三遍:如果我写一个方法,参数是Admin类型,那么我可以调用这个方法直接传入lambda表达式即可,为什么连说三遍呢?因为这是最流行的用法,也是lambda的风骚之处:传递行为。
比如:
private static void myName(Admin admin){ String name = admin.getName(); System.out.println(name); }
然后我可以这么调用:myName(()->"张三");
但是本篇博客剩下的例子几乎不会这样子写,是因为代码多了不易让人理解,因此尽量写的直接一些。
当然,老土的办法是用内部类来实现:
Admin admin = new Admin() { @Override public String getName() { return "张三"; } }; System.out.println(admin.getName());
类型检查与类型推断
为什么下面这个代码不能编译呢?
Object o = () -> System.out.println("张三");
因为lambda表达式上下文的目标类型必须是一个函数式接口,而Object并不是函数式接口
我下面这个接口是函数式接口
public interface User { String userInfo(String name,int age); }
那么我这样子可以吗?
User user = () -> System.out.println("张三");
也是不行的,因为User接口的抽象方法是有入参也有返回值的,但是() -> System.out.println("张三")却是一个没有入参也没有返回值的表达式。
所以说lambda表达式的入参和返回值必须要和函数式接口兼容。
User函数式接口的入参是String和int,返回值是String,正确的用法应该是这样的:
String name = "小红"; int age = 19; User user = (String username,int userage) -> { return username+"今年"+userage+"岁了"; }; System.out.println(user.userInfo(name,age));
可以更简洁一点吗? 可以的。
Java编译器会从上下文来推断出用什么函数式接口来配合lambda表达式,它也可以推断出适合lambda表达式的签名。
就像我们经常使用的菱形运算符一样:
HashMap<String,Integer> map1 = new HashMap<String,Integer>(); HashMap<String,Integer> map2 = new HashMap<>();
因此省略参数类型也是可以的:
User user = (username,userage) -> { return username+"今年"+userage+"岁了"; };
有时候写明参数类型更易读,有时候省略参数类型更易读,这个就是仁者见仁智者见智了。
还可以再简洁一点吗?当然可以。
注意这个lambda表达式的主体,并不是什么复杂的计算流程,它仅仅只是一个普通的表达式。
所以可以不用块表达式:
User<String> user2 = (username,userage) -> username+"今年"+userage+"岁了";
就这样一行代码就完事,自带隐式的return。
泛型函数式接口
lambda表达式的类型推断是相当的智能,不过,如果我写这么个函数式接口,泛型,试一试它还能不能智能的起来?
public interface MyUser<T> { String userInfo(String name,T age); }
显然不可能,编译都过不了,因为它已经懵逼了,不知道你的参数到底是个什么类型。
这时候,就需要在lambda表达式的目标类型上指定参数类型:
String name = "小芳"; int age1 = 17; double age2 = 17.5; MyUser<Integer> myUser = (n,a) -> n+a; String str1 = myUser.userInfo(name,age1); System.out.println(str1); MyUser<Double> myUser1 = (n,a) -> n+a; String str2 = myUser1.userInfo(name,age2); System.out.println(str2);
引用值,而不是变量
我们目前为止在lambda表达式主体中使用的变量都是传进来的参数,在lambda表达式中,可以访问外层作用域定义的变量,将其引用为当前表达式内的局部变量,这叫做变量捕获。
在这种情况下,lambda表达式只能使用final的局部变量,也就是说,被lambda表达式捕获的外层变量,都会自动变成实质上的final类型,final变量是指在第一次赋值以后,值不能再发生变化的变量。
示例:
String name = "小红"; int age = 22; int status = 1; User user = (n,a) -> { //status ++; //不允许 return n+a+"状态是"+status; }; //status ++; //不允许 String str = user.userInfo(name,age); System.out.println(str);
示例中的status变量被lambda表达式捕获之后,在lambda表达式中不能修改,在外层也不能被修改,
实际上lambda在访问外层变量时,访问的是变量的副本,并不是原始变量。
换句话说,lambda表达式引用的是值,而不是变量。
方法引用
深入剖析方法引用
方法引用的基本思想是:如果一个lambda表达式代表的只是直接调用这个方法,那么最好还是用名称来调用它,而不是去描述如何调用它。
方法引用提供了一种引用而不执行的方式,这种特性与lambda表达式相关,因为它也需要由兼容的函数式接口构成的目标类型上下文,运行的时候,方法引用也会创建函数式接口的一个实例。
当你需要使用方法引用时,目标引用放在分隔符::前,方法名称放在后面,例如User::getName就是引用了User类中的getName()方法,请记住,不需要括号,因为你没有实际调用这个方法,它其实就是(User a)->a.getName()的快捷写法。
下面走一个例子:
函数式接口
public interface User { String userInfo(String name,int age); }
处理用户信息的类
public class MyInfo { static String name(String name,int age){ if(age < 18){ name = "少年人"+name; }else if(age > 18 && age< 28){ name = "青年人"+name; }else{ name = "老年人"+name; } return name+"年龄是"+age; } }
接口调用方法
public static String userThink(User user,String name,int age){ return user.userInfo(name,age); }
主函数
public static void main(String[] args) { String name = "小明"; int age = 15; String outStr = userThink(MyInfo::name,name,age); System.out.println(outStr); }
观察可以得知 MyInfo::name进入userThink方法之后变成了User接口的一个实例,MyInfo类的name方法需要两个参数,而引用的时候并没有传参,因此更加证实了方法引用并非方法调用。
如果我这么改一下 你可能会恍然大悟:
User user = MyInfo::name; String info = user.userInfo(name,age); System.out.println(info);
原来引用的方法就是lambda表达式的主体,牢记这一点非常重要。
因此我们这么下结论:如果lambda表达式的主体内容是调用一个方法,那么就可以使用方法引用,当然,引用的方法必须与上下文所使用的函数式接口相兼容。
下面介绍几种方法引用的例子:
lambda表达式 | 等效的方法引用 |
() -> Thread.currentThread().dumpStack() | Thread.currentThread()::dumpStack |
(str,i) -> str.substring(i) | String::substring |
(String s) -> System.out.println(s) | System.out::println |
本节示例MyInfo中的name方法是一个静态方法,如果不是静态方法呢?
不是静态方法的话,那么就需要将整个类new出来,再进行该对象的方法引用。
还有一种情况,就如上面表格中的(str,i) -> str.substring(i)为什么可以用方法引用String::substring来替代呢?
substring是静态方法吗? 不是的。
String类有new出来吗? 也没有。
原因只有一个:String实例是传入lambda表达式的参数,因此str本身就是String的实例,拥有String的所有方法。
如果你要引用一个对象的方法,而这个对象本身是lambda的一个参数,那么Java允许你直接引用。
构造函数引用
构造器引用与方法引用是一样的,只不过方法名固定为new,例如:Admin::new是Admin构造器的一个引用,它就相当于 () -> new Admin(),注意,也就是说当前使用的函数式接口的返回类型必须兼容Admin。
下面走一个示例(写示例是最头疼的事情了 汗):
一个学生类
public class Student { String name; int grade = 0; public Student(String name) { this.name = name; } public Student(String name, int grade) { this.name = name; this.grade = grade; } public String getName() { return name; } public int getGrade() { return grade; } }
函数式接口 返回类型是Student
public interface StudentInterface { Student getStudent(String name,int grade); }
代码这么走:
StudentInterface studentInterface = Student::new; Student student = studentInterface.getStudent("小明",2); System.out.println(student.getName()+student.getGrade());
思考一下,Student类中有两个构造函数,为什么代码就逮着第二个构造函数走呢?
这就是lambda的类型推断特性了,走哪个构造函数是根据上下文的函数式接口来决定的,StudentInterface接口的入参是两个参数,一个String一个int,返回类型是Student,出入条件都符合第二个构造函数,所以它就会走第二个构造函数。
那如果我要走第一个构造函数该怎么做呢?
很简单,稍微改一下
public interface StudentInterface2 { Student getStudent(String name); }
用这个函数式接口去接收方法引用即可。
泛型中的方法引用
在泛型类或泛型方法中也可以使用方法引用,再来一个例子:
这个是要引用的泛型方法
public class MyInfo2 { static <T> String name(String name,T age){ return name+"年龄是"+age; } }
函数式接口
public interface MyUser<T> { String userInfo(String name,T age); }
调用
String name = "小明"; int age = 16; double a = 16.6; MyUser user = MyInfo2::name; String info = user.userInfo(name,age); System.out.println(info);
这里传int或double都是可以的。
如果要限制只能传int呢?
那就这样子
MyUser<Integer> user = MyInfo2::name; //这时传double就不行了
请注意,它的原型实际上是这样的:
MyUser<Integer> user = MyInfo2::<Integer>name;
但是由于存在类型推断,所以::后面的类型指定是可以省略的。
内置的函数式接口
当我们设计自己的函数式接口时,可以用注解@FunctionalInterface来标记这个接口,这样子这个接口就只能成为函数式接口,不允许再增加别的抽象方法,另外javadoc里也会指出这是一个函数式接口。
当然,最好还是使用Java给我们内置的函数式接口,个人认为已经可以满足大部分编程需要了,并且很多接口都有非抽象的方法可以使用。
以下列出常用的函数式接口:
函数式接口 | 返回类型 | 参数类型 | 抽象方法名 |
Runnable | void | 无 | run |
Supplier<T> | T | 无 | get |
Consumer<T> | void | T | accept |
BiConsumer<T,U> | void | T,U | accept |
Function<T,R> | R | T | apply |
BiFunction<T,U,R> | R | T,U | apply |
UnaryOperator<T> | T | T | apply |
BinaryOperator<T> | T | T,T | apply |
Predicate<T> | boolean | T | test |
BiPredicate<T,U> | boolean | T,U | test |
基本类型函数式接口
如 ToLongFunction IntToLongFunction IntConsumer 等等等等 接口名称已经代表了他们的功能
有三四十个这样的函数式接口,我这里就不方便出来了,详细请查阅java.util.function包。
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
上一篇:Elasticsearch查询
下一篇:汉诺塔问题
- Java 简介 2020-06-09
- 黑菜菌的JAVA学习笔记 2020-06-09
- 学习笔记之Lambda表达式 2020-06-05
- JAVA8 Stream流 2020-06-02
- Redis入门实战(1)-简介 2020-05-31
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash