博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Java8新特性之一:Lambda表达式
阅读量:6427 次
发布时间:2019-06-23

本文共 6457 字,大约阅读时间需要 21 分钟。

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包下,读者可去这个包下去查询。

原文地址

转载地址:http://usfga.baihongyu.com/

你可能感兴趣的文章
C++返回引用的函数例程
查看>>
dll 问题 (转)
查看>>
REST API用得也痛苦
查看>>
test for windows live writer plugins
查看>>
Tiny210 U-BOOT(二)----配置时钟频率基本原理
查看>>
VS Code折腾记 - (3) 多图解VSCode基础功能
查看>>
『翻译』Node.js 调试
查看>>
我的iOS开发之路总结(更新啦~)
查看>>
Java NIO之拥抱Path和Files
查看>>
微信原图泄露的只能是 Exif ,你的隐私不在这!!!
查看>>
微信小程序教学第三章(含视频):小程序中级实战教程:列表篇-页面逻辑处理...
查看>>
页面间通信与数据共享解决方案简析
查看>>
Swift 中 Substrings 与 String
查看>>
作为一个开源软件的作者是一种什么样的感受?
查看>>
移动端适配知识你到底知多少
查看>>
TiDB 在 G7 的实践和未来
查看>>
重新认识javascript对象(三)——原型及原型链
查看>>
小学生学“数学”
查看>>
FastDFS蛋疼的集群和负载均衡(十七)之解决LVS+Keepalived遇到的问题
查看>>
深入剖析Redis系列(二) - Redis哨兵模式与高可用集群
查看>>