Java8新特性之一：Lambda表达式

你的名字 2022-02-14 11:57 131阅读 0赞

Java8新特性之一：Lambda表达式  
Java8是自java5之后最重大的一次更新，它给JAVA语言带来了很多新的特性（包括编译器、类库、工具类、JVM等），其中最重要的升级是它给我们带来了Lambda表达式和Stream API。

1、什么是Lambda表达式？  
　　Lambda是一个匿名函数，可以理解为是一段可以传递的代码，可以将代码像传递参数、传递数据一样进行传输。使用Lambda表达式，可以写出更加紧凑、更加简洁、更加灵活的代码。

2、使用Lambda的限制条件  
　　Lambda并不是任何地方都可以使用，Lambda表达式需要“函数式接口”的支持。

3、什么是函数式接口？  
　　接口中只有一个抽象方法的接口，称为函数式接口，可以用@FunctionalInterface修饰一下，这里需要注意的是：未使用 @FunctionalInterfaces注解的接口未必就不是函数式接口，一个接口是不是函数式接口的条件只有一条，即接口中只有一个抽象方法的接口（Object类中的方法不算）。而使用@FunctionalInterface注解修饰了的接口就一定是函数式接口，添加@FunctionalInterface注解可以帮助我们检查是否是函数式接口。

JDK中常见的函数式接口有：

1 @FunctionalInterface  
2 public interface Runnable \{  
3 void run();  
4 \}  
1 @FunctionalInterface  
2 public interface Callable \{  
3 V call() throws Exception;  
4 \}  
以下接口中虽然有两个方法，但因hashCode()是Object类中的方法，因此该接口也是函数式接口：

复制代码  
1 @FunctionalInterface  
2 public interface FuncInterface \{  
3  
4 void doSomething();  
5  
6 int hashCode(); // Object类中的方法  
7 \}  
复制代码  
4、Lambda表达式示例  
　　需求一：开启一个线程，在线程中打印出"Hello World"

未使用Lambda表达式时的写法：

复制代码  
1 public class LambdaTest \{  
2  
3 public void print() \{  
4  
5 Thread thread = new Thread(new Runnable() \{  
6 @Override  
7 public void run() \{  
8 System.out.println("Hello World");  
9 \}  
10 \});  
11  
12 thread.start();  
13 \}14 \}  
复制代码  
　　使用Lambda时的写法：

1 public class LambdaTest \{  
2  
3 public void print() \{  
4 Thread thread = new Thread(() -> System.out.println("Hello World"));  
5 \}  
6 \}  
　　需求二：模拟一个计算器，使其可以进行简单的加、减、乘操作

（1）、计算器操作函数式接口

1 @FunctionalInterface  
2 public interface Calculator \{  
3 T operation(T t1,T t2);  
4 \}  
　　（2）具体操作

复制代码  
1 public class CalculatorTest \{  
2  
3 public Integer operator(Integer v1,Integer v2,Calculator calculator) \{  
4 return calculator.operation(v1,v2);  
5 \}  
6  
7 public Integer add(Integer v1,Integer v2) \{  
8 return operator(v1,v2,(x,y) -> x + y);  
9 \}  
10  
11 public Integer subtr(Integer v1,Integer v2) \{  
12 return operator(v1,v2,(x,y) -> x - y);  
13 \}  
14  
15 public Integer multi(Integer v1,Integer v2) \{  
16 return operator(v1,v2,(x,y) -> x \* y);  
17 \}  
18  
19 public static void main(String\[\] args) \{  
20  
21 CalculatorTest calculatorTest = new CalculatorTest();  
22  
23 // 加法  
24 Integer add = calculatorTest.add(1,2);  
25  
26 // 减法  
27 Integer sub = calculatorTest.subtr(100,82);  
28  
29 // 乘法  
30 Integer multi = calculatorTest.multi(5,3);  
31  
32 System.out.println(add);  
33 System.out.println(sub);  
34 System.out.println(multi);  
35 \}  
36 \}  
复制代码  
　　运行结果：

3  
18  
15  
　　从需求一中，我们可以看出，使用Lambda比使用匿名内部类代码更加简洁，同时，也可以理解为什么Lambda必须需要函数式接口的支持。我们假设Runnable中有两个方法，那么，“() -> System.out.println(Thread.currentThread().getName())”应该去找哪个方法去实现？

从需求二的例子中，我们可以更加理解“一段可以传递的代码”这句话的含义。对数据的操作方法定义在Calculator接口中，而加、减、乘的具体实现代码在各自的方法中，并将这些实现作为参数传递给CalculatorTest类的operator()方法，最终返回操作结果。

5、Lambda表达式的语法  
5.1 Lambda表达式的语法结构  
(参数列表，对应的是接口中对应的抽象方法的参数列表) -> \{对抽象方法的实现\}  
　　Lambda表达式语法分在3个部分：

左边的参数列表，对应的是函数式接口中抽象方法的参数列表；  
中间的符号:->,为固定写法;  
右边大括号内对函数接口抽象方法的实现。  
　　Lambda表达式的在具体场景下可以有简略写法。

5.2 语法格式一：无参数，无返回值  
1 Runnable runnable = () -> \{System.out.println("Hello World");\}  
2 Runnable runnable = () -> System.out.println("Hello World"); // 简写形式  
　　此时，如果右边的代码简单，只有一行代码时，\{\}可以省略。

5.2 语法格式二：有一个参数，无返回值  
复制代码  
1 public class CalculatorTest \{  
2  
3 public void print(Consumer msg) \{  
4 System.out.println(msg);  
5 \}  
6  
7 public void doPrint(String msg) \{  
8 print((str) -> System.out.println(msg));  
9 print(str -> System.out.println(msg)); // 简写  
10  
11 \}  
12 \}  
复制代码  
　　此时，左边的()可以省略。

5.3 语法格式三：Lambda体内只有一条语句，且有返回值，return可省略  
1 public Integer subtr(Integer v1,Integer v2) \{  
2 return operator(v1,v2,(x,y) -> x - y);  
3 \}  
5.4 语法格式四：有两个以上参数，且Lambda体中有多条语句  
1 public Integer add(Integer v1,Integer v2) \{  
2 return operator(v1,v2,(x,y) -> \{  
3 System.out.println("进行加法运算");  
4 return x + y;  
5 \});  
6 \}  
5.5 语法格式五：Lambda表达式的数据类型可以省略不写  
　　JVM编译器通过上下文可以推断出数据类型，但要注意的是，当多个参数时，要么都写，要么都不写，不能有的写，有的不写：

复制代码  
1 public Integer subtr(Integer v1,Integer v2) \{  
2 return operator(v1,v2,(Integer x,y) -> x - y); // 错误  
3 \}  
4  
5 public Integer subtr(Integer v1,Integer v2) \{  
6 return operator(v1,v2,(x,y) -> x - y); // 正确  
7 \}  
复制代码  
6、Java8四大内置核心函数式接口  
复制代码  
Consumer : 消费型接口（无返回值，有去无回）

void accept(T t);

Supplier : 供给型接口

T get();

Function : 函数型接口

R apply(T t);

Predicate : 断言型接口

boolean test(T t);

四大核心接口的-->扩展子接口  
复制代码  
　　示例：

复制代码  
1 import lombok.Getter;  
2 import lombok.Setter;  
3  
4 import java.util.function.Consumer;  
5 import java.util.function.Function;  
6 import java.util.function.Predicate;  
7 import java.util.function.Supplier;  
8  
9 @Getter  
10 @Setter  
11 class User \{  
12 private String username;  
13 private int age;  
14  
15 @Override  
16 public String toString() \{  
17 return "User\{" +  
18 "username='" + username + ''' +  
19 ", age=" + age +  
20 '\}';  
21 \}  
22 \}  
23  
24 public class InnerInterface \{  
25  
26 /\*\*  
27 \* 打印user信息  
28 \*/  
29 public void print(User user,Consumer userConsumer) \{  
30 userConsumer.accept(user);  
31 \}  
32  
33 /\*\*  
34 \* 返回一个user  
35 \*/  
36 public User getUser(Supplier userSupplier) \{  
37 return userSupplier.get();  
38 \}  
39  
40 /\*\*  
41 \* 转换一个user  
42 \*/  
43 public User transformUser(User user,Function function) \{  
44 return function.apply(user);  
45 \}  
46  
47 /\*\*  
48 \* 检验User是否合法  
49 \*/  
50 public boolean checkUser(User user, Predicate predicate) \{  
51 return predicate.test(user);  
52 \}  
53  
54 public static void main(String\[\] args) \{  
55  
56 User userObj = new User();  
57 userObj.setUsername("西门吹雪");  
58 userObj.setAge(22);  
59  
60 // 测试Consumer  
61 InnerInterface mainInst = new InnerInterface();  
62 mainInst.print(userObj,user -> System.out.println(user));  
63  
64 // 测试Supplier  
65 final User user1 = mainInst.getUser(() -> \{  
66 User user = new User();  
67 user.setUsername("叶孤城");  
68 user.setAge(22);  
69 return user;  
70 \});  
71 System.out.println(user1);  
72  
73 // 将西门吹雪的年龄改为25  
74 final User user2 = mainInst.transformUser(userObj, (user -> \{  
75 user.setAge(25);  
76 return user;  
77 \}));  
78 System.out.println(user2);  
79  
80 // 判断User是否是西门吹雪  
81 final boolean checkUser = mainInst.checkUser(userObj, (user -> user.getUsername().equals("西门吹雪")));  
82 System.out.println(checkUser);  
83 \}  
84 \}  
复制代码  
　　运行结果：

User\{username='西门吹雪', age=22\}  
User\{username='叶孤城', age=22\}  
User\{username='西门吹雪', age=25\}  
true  
　　以上四大核心内置接口是我们日常开发中经常要用到的，同时，它们还有一些变种，如：

BiConsumer，Consumer的增强版，接受两个参数：

1 @FunctionalInterface  
2 public interface BiConsumer \{  
3  
4 void accept(T t, U u);  
5 \}  
　　BiFunction类似，Function的增强版，接受两个参数，返回一个参数：

复制代码  
1 @FunctionalInterface  
2 public interface BiFunction \{  
3  
4 R apply(T t, U u);  
5  
6 default BiFunction andThen(Function<? super R, ? extends V> after) \{  
7 Objects.requireNonNull(after);  
8 return (T t, U u) -> after.apply(apply(t, u));  
9 \}  
10 \}  
复制代码  
　　其他的类似，这些函数式接口都在java.util.function包下，读者可去这个包下去查询。

原文地址[https://www.cnblogs.com/wuhenzhidu/p/lambda.html][https_www.cnblogs.com_wuhenzhidu_p_lambda.html]

[https_www.cnblogs.com_wuhenzhidu_p_lambda.html]: https://www.cnblogs.com/wuhenzhidu/p/lambda.html