文章目录
1. 什么是Lambda表达式
Lambda表达式,也可称为闭包。类似于JavaScript中的闭包,它是推动Java8发布的最重要的新特性。
2. 为什么使用Lambda表达式
我们可以把Lambda表达式理解为一段可以传递的代码(将代码像数据一样进行传递)。Lambda允许把函数作为一个方法的参数,使用Lambda表达式可以写出更简洁、更灵活的代码,而其作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升。
一个简单示例:
分别使用成员内部类、局部内部类、静态内部类、匿名内部类方式实现Runnable的run()方法并创建和启动线程,如下所示:
public class LambdaDemo {
/**
* 成员内部类
*/
class MyThread01 implements Runnable{
@Override
public void run() {
System.out.println("成员内部类:用Lambda语法创建线程吧!");
}
}
/**
* 静态内部类
*/
static class MyThread02 implements Runnable{
@Override
public void run() {
System.out.println("静态内部类:对啊,用Lambda语法创建线程吧!");
}
}
public static void main(String[] args) {
/**
* 局部内部类
*/
class MyThread03 implements Runnable{
@Override
public void run() {
System.out.println("局部内部类:用Lambda语法创建线程吧!");
}
}
/**
* 匿名内部类
*/
Runnable runnable = new Runnable(){
@Override
public void run() {
System.out.println("匿名内部类:求求你,用Lambda语法创建线程吧!");
}
};
//成员内部类方式
LambdaDemo lambdaDemo = new LambdaDemo();
MyThread01 myThread01 =lambdaDemo.new MyThread01();
new Thread(myThread01).start();
//静态内部类方式
MyThread02 myThread02 = new MyThread02();
new Thread(myThread02).start();
//局部内部类
MyThread03 myThread03 = new MyThread03();
new Thread(myThread03).start();
//匿名内部类的方式
new Thread(runnable).start();
}
}
执行结果:
可以看到上面创建方式,代码量都不少,使用Lambda表达式实现,如下所示:
//Lambda方式
new Thread(() -> System.out.println("使用Lambda就对了")).start();
可以看到代码明显简洁了许多。
3. Lambda表达式语法
Lambda表达式在Java语言中引入了一个操作符**“->”**,该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分:
- 左侧:指定了Lambda表达式需要的所有参数
- 右侧:制定了Lambda体,即Lambda表达式要执行的功能。
像这样:
(parameters) -> expression
或
(parameters) ->{ statements; }
以下是lambda表达式的重要特征:
- 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值。
- 可选的参数圆括号:一个参数无需定义圆括号,但无参数或多个参数需要定义圆括号。
- 可选的大括号:如果主体包含了一个语句,就不需要使用大括号。
- 可选的返回关键字:如果主体只有一个表达式返回值则编译器会自动返回值,大括号需要指定明表达式返回了一个数值。
下面对每个语法格式的特征进行举例说明:
(1)语法格式一:无参,无返回值,Lambda体只需一条语句。如下:
@Test
public void test01(){
Runnable runnable=()-> System.out.println("Runnable 运行");
runnable.run();//结果:Runnable 运行
}
(2)语法格式二:Lambda需要一个参数,无返回值。如下:
@Test
public void test02(){
Consumer<String> consumer=(x)-> System.out.println(x);
consumer.accept("Hello Consumer");//结果:Hello Consumer
}
(3)语法格式三:Lambda只需要一个参数时,参数的小括号可以省略,如下:
public void test02(){
Consumer<String> consumer=x-> System.out.println(x);
consumer.accept("Hello Consumer");//结果:Hello Consumer
}
(4)语法格式四:Lambda需要两个参数,并且Lambda体中有多条语句。
@Test
public void test04(){
Comparator<Integer> com=(x, y)->{
System.out.println("函数式接口");
return Integer.compare(x,y);
};
System.out.println(com.compare(2,4));//结果:-1
}
(5)语法格式五:有两个以上参数,有返回值,若Lambda体中只有一条语句,return和大括号都可以省略不写
@Test
public void test05(){
Comparator<Integer> com=(x, y)-> Integer.compare(x,y);
System.out.println(com.compare(4,2));//结果:1
}
(6)Lambda表达式的参数列表的数据类型可以省略不写,因为JVM可以通过上下文推断出数据类型,即“类型推断”
@Test
public void test06(){
Comparator<Integer> com=(Integer x, Integer y)-> Integer.compare(x,y);
System.out.println(com.compare(4,2));//结果:1
}
类型推断:在执行javac编译程序时,JVM根据程序的上下文推断出了参数的类型。Lambda表达式依赖于上下文环境。
语法背诵口诀:左右遇一括号省,左侧推断类型省,能省则省。
4. 函数式接口
4.1 什么是函数式接口
==只包含一个抽象方法的接口,就称为函数式接口。==我们可以通过Lambda表达式来创建该接口的实现对象。
我们可以在任意函数式接口上使用@FunctionalInterface注解,这样做可以用于检测它是否是一个函数式接口,同时javadoc也会包含一条声明,说明这个接口是一个函数式接口。
4.2 自定义函数式接口
按照函数式接口的定义,自定义一个函数式接口,如下:
@FunctionalInterface
public interface MyFuncInterf<T> {
public T getValue(String origin);
}
定义一个方法将函数式接口作为方法参数。
public String toLowerString(MyFuncInterf<String> mf,String origin){
return mf.getValue(origin);
}
将Lambda表达式实现的接口作为参数传递。
public void test07(){
String value=toLowerString((str)->{
return str.toLowerCase();
},"ABC");
System.out.println(value);//结果ABC
}
4.3 Java内置函数式接口
四大核心函数式接口的介绍,如图所示:
使用示例:
1.Consumer:消费型接口 void accept(T t)
public void makeMoney(Integer money, Consumer<Integer> consumer){
consumer.accept(money);
}
@Test
public void test01(){
makeMoney(100,t-> System.out.println("今天赚了"+t));//结果:今天赚了100
}
2.Supplier:供给型接口 T get()
/**
* 产生指定的整数集合放到集合中
* Iterable接口的forEach方法的定义:方法中使用到了Consumer消费型接口,
* default void forEach(Consumer<? super T> action) {
* Objects.requireNonNull(action);
* for (T t : this) {
* action.accept(t);
* }
* }
*/
@Test
public void test02(){
List list = addNumInList(10, () -> (int) (Math.random() * 100));
list.forEach(t-> System.out.println(t));
}
public List addNumInList(int size, Supplier<Integer> supplier){
List<Integer> list=new ArrayList();
for (int i = 0; i < size; i++) {
list.add(supplier.get());
}
return list;
}
3.Function<T,R>:函数型接口 R apply(T t)
/**
*
* 使用函数式接口处理字符串。
*/
public String handleStr(String s,Function<String,String> f){
return f.apply(s);
}
@Test
public void test03(){
System.out.println(handleStr("abc",(String s)->s.toUpperCase()));
}
//结果:ABC
4.Predicate:断言型接口 boolean test(T t)
/**
* 自定义条件过滤字符串集合
*/
@Test
public void test04(){
List<String> strings = Arrays.asList("啊啊啊", "2333", "666", "?????????");
List<String> stringList = filterStr(strings, (s) -> s.length() > 3);
for (String s : stringList) {
System.out.println(s);
}
}
public List<String> filterStr(List<String> list, Predicate<String> predicate){
ArrayList result = new ArrayList();
for (int i = 0; i < list.size(); i++) {
if (predicate.test(list.get(i))){
result.add(list.get(i));
}
}
return result;
}
其他接口的定义,如图所示:
5. 方法引用
当要传递给Lambda体的操作,已经有实现的方法了,就可以使用方法引用!(实现抽象方法的参数列表,必须与方法引用的参数列表一致,方法的返回值也必须一致,即方法的签名一致)。方法引用可以理解为方法引用是Lambda表达式的另外一种表现形式。
方法引用的语法:使用操作符“::”将对象或类和方法名分隔开。
方法引用的使用情况共分为以下三种:
- 对象::实例方法名
- 类::静态方法名
- 类::实例方法名
使用示例:
1.对象::实例方法名
/**
*PrintStream中的println方法定义
* public void println(String x) {
* synchronized (this) {
* print(x);
* newLine();
* }
* }
*/
//对象::实例方法名
@Test
public void test1(){
PrintStream out = System.out;
Consumer<String> consumer=out::println;
consumer.accept("hello");
}
- 类::静态方法名
/**
* Integer类中的静态方法compare的定义:
* public static int compare(int x, int y) {
* return (x < y) ? -1 : ((x == y) ? 0 : 1);
* }
*/
@Test
public void test2(){
Comparator<Integer> comparable=(x,y)->Integer.compare(x,y);
//使用方法引用实现相同效果
Comparator<Integer> integerComparable=Integer::compare;
System.out.println(integerComparable.compare(4,2));//结果:1
System.out.println(comparable.compare(4,2));//结果:1
}
3.类::实例方法名
@Test
public void test3(){
BiPredicate<String,String> bp=(x,y)->x.equals(y);
//使用方法引用实现相同效果
BiPredicate<String,String> bp2=String::equals;
System.out.println(bp.test("1","2"));//结果:false
System.out.println(bp.test("1","2"));//结果:false
}
6. 构造器引用
格式:类名::new
与函数式接口相结合,自动与函数式接口中方法兼容,可以把构造器引用赋值给定义的方法。需要注意构造器参数列表要与接口中抽象方法的参数列表一致。使用示例:
创建一个实体类Employee:
public class Employee {
private Integer id;
private String name;
private Integer age;
@Override
public String toString() {
return "Employee{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
public Employee(){
}
public Employee(Integer id) {
this.id = id;
}
public Employee(Integer id, Integer age) {
this.id = id;
this.age = age;
}
public Employee(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
}
使用构造器引用与函数式接口相结合
@Test
public void test01(){
//引用无参构造器
Supplier<Employee> supplier=Employee::new;
System.out.println(supplier.get());
//引用有参构造器
Function<Integer,Employee> function=Employee::new;
System.out.println(function.apply(21));
BiFunction<Integer,Integer,Employee> biFunction=Employee::new;
System.out.println(biFunction.apply(8,24));
}
输出结果:
Employee{id=null, name='null', age=null}
Employee{id=21, name='null', age=null}
Employee{id=8, name='null', age=24}
7. 数组引用
数组引用的格式:type[]:new
使用示例:
@Test
public void test02(){
Function<Integer,String[]> function=String[]::new;
String[] apply = function.apply(10);
System.out.println(apply.length);//结果:10
}
8. Lambda表达式的作用域
Lambda表达式可以看作是匿名内部类实例化的对象,Lambda表达式对变量的访问限制和匿名内部类一样,因此Lambda表达式可以访问局部变量、局部引用,静态变量,实例变量。
8.1 访问局部变量
在Lambda表达式中规定只能引用标记了final的外层局部变量。我们不能在lambda 内部修改定义在域外的局部变量,否则会编译错误。
public class TestFinalVariable {
interface VarTestInterface{
Integer change(String str);
}
public static void main(String[] args) {
//局部变量不使用final修饰
Integer tempInt = 1;
VarTestInterface var = (str -> Integer.valueOf(str+tempInt));
//再次修改,不符合隐式final定义
tempInt =2;
Integer str =var.change("111") ;
System.out.println(str);
}
}
上面代码会出现编译错误,出现如下提示:
特殊情况下,局部变量也可以不用声明为 final,但是必须不可被后面的代码修改(即隐性的具有 final 的语义)
例如上面的代码确保Lambda表达式后局部变量后面不做修改,就可以成功啦!
public class TestFinalVariable {
interface VarTestInterface{
Integer change(String str);
}
public static void main(String[] args) {
//局部变量不使用final修饰
Integer tempInt = 1;
VarTestInterface var = (str -> Integer.valueOf(str+tempInt));
Integer str =var.change("111") ;
System.out.println(str);
}
}
8.2 访问局部引用,静态变量,实例变量
Lambda表达式不限制访问局部引用变量,静态变量,实例变量。代码测试都可正常执行,代码:
public class LambdaScopeTest {
/**
* 静态变量
*/
private static String staticVar;
/**
* 实例变量
*/
private String instanceVar;
@FunctionalInterface
interface VarChangeInterface{
Integer change(String str);
}
/**
* 测试引用变量
*/
private void testReferenceVar(){
ArrayList<String> list = new ArrayList<>();
list.add("111");
//访问外部引用局部引用变量
VarChangeInterface varChangeInterface = ((str) -> Integer.valueOf(list.get(0)));
//修改局部引用变量
list.set(0,"222");
Integer str =varChangeInterface.change("");
System.out.println(str);
}
/**
* 测试静态变量
*/
void testStaticVar(){
staticVar="222";
VarChangeInterface varChangeInterface = (str -> Integer.valueOf(str+staticVar));
staticVar="333";
Integer str =varChangeInterface.change("111") ;
System.out.println(str);
}
/**
* 测试实例变量
*/
void testInstanceVar(){
instanceVar="222";
VarChangeInterface varChangeInterface = (str -> Integer.valueOf(str+instanceVar));
instanceVar="333";
Integer str =varChangeInterface.change("111") ;
System.out.println(str);
}
public static void main(String[] args) {
new LambdaScopeTest().testReferenceVar();
new LambdaScopeTest().testStaticVar();
new LambdaScopeTest().testInstanceVar();
}
}
Lambda表达式里不允许声明一个与局部变量同名的参数或者局部变量。
//编程报错
Integer tempInt = 1;
VarTestInterface varTest01 = (tempInt -> Integer.valueOf(tempInt));
VarTestInterface varTest02 = (str -> {
Integer tempInt = 1;
Integer.valueOf(str);
});
8.3 Lambda表达式访问局部变量作限制的原因
Lambda表达式不能访问非final修饰的局部变量的原因是,局部变量是保存在栈帧中的。而在Java的线程模型中,栈帧中的局部变量是线程私有的,如果允许Lambda表达式访问到栈帧中的变量地址(可改变的局部变量),则会可能导致线程私有的数据被并发访问,造成线程不安全问题。
基于上述,对于引用类型的局部变量,因为Java是值传递,又因为引用类型的指向内容是保存在堆中,是线程共享的,因此Lambda表达式中可以修改引用类型的局部变量的内容,而不能修改该变量的引用。
对于基本数据类型的变量,在 Lambda表达式中只是获取到该变量的副本,且局部变量是线程私有的,因此无法知道其他线程对该变量的修改,如果该变量不做final修饰,会造成数据不同步的问题。
但是实例变量,静态变量不作限制,因为实例变量,静态变量是保存在堆中(Java8之后),而堆是线程共享的。在Lambda表达式内部是可以知道实例变量,静态变量的变化。
9. Lambda表达式的优缺点
- 优点:
- 使代码更简洁,紧凑
- 可以使用并行流来并行处理,充分利用多核CPU的优势
有利于JIT编译器对代码进行优化
- 缺点:
- 非并行计算情况下,其计算速度没有比传统的 for 循环快
- 不容易调试
- 若其他程序员没有学过 Lambda 表达式,代码不容易看懂
在Stream操作中使用lambda表达式:Java8新特性Stream的使用总结
笔记总结自:尚硅谷的视频教程-【Java8新特性】
参考:
1.Java 8 Lambda 表达式
2.Lambda-让人又爱又恨的“->"
推荐阅读:聊聊Java 8 Lambda 表达式