1. Lambda 介绍
在 Java 中 Lambda 表达式（lambda expression）是一个匿名函数，在编写 Java 中的 Lambda 的时候，你也会发现 Lambda 不仅没有函数名称，有时候甚至连入参和返回都可以省略，这也让代码变得更加紧凑。
2. Lambda 语法
Lambda 的语法主要是下面几种。
1. (params) -> expression
2. (params) -> {statements;}
Lambda 的语法特性。
- 使用 ->分割 Lambda 参数和处理语句。
- 类型可选，可以不指定参数类型，编译器可以自动判断。
- 圆括号可选，如果只有一个参数，可以不需要圆括号，多个参数必须要圆括号。
- 花括号可选，一个语句可以不用花括号，多个参数则花括号必须。
- 返回值可选，如果只有一个表达式，可以自动返回，不需要 return 语句；花括号中需要 return 语法。
- Lambda 中引用的外部变量必须为 final 类型，内部声明的变量不可修改，内部声明的变量名称不能与外部变量名相同。
举几个具体的例子， params 在只有一个参数或者没有参数的时候，可以直接省略不写，像这样。
// 1.不需要参数，没有返回值，输出 hello
()->System.out.pritnln("hello");
// 2.不需要参数，返回 hello
()->"hello";
// 3. 接受2个参数(数字),返回两数之和
(x, y) -> x + y
// 4. 接受2个数字参数,返回两数之和
(int x, int y) -> x + y
// 5. 两个数字参数，如果都大于10，返回和，如果都小于10，返回差
(int x,int y) ->{
if( x > 10 && y > 10){
return x + y;
}
if( x < 10 && y < 10){
return Math.abs(x-y);
}
};
通过上面的几种情况，已经可以大致了解 Lambda 的语法结构了。
3. Lambda 使用
3.1 对于函数接口
我们已经知道了 Runnable 接口已经是函数接口了，它可以隐式的转换为 Lambda 表达式进行使用，通过下面的创建线程并运行的例子看下 Java 8 中 Lambda 表达式的具体使用方式。
/**
* Lambda 的使用，使用 Runnable 例子
* @throws InterruptedException
*/
@Test
public void createLambda() throws InterruptedException {
// 使用 Lambda 之前
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("JDK8 之前的线程创建");
}
};
new Thread(runnable).start();
// 使用 Lambda 之后
Runnable runnable1Jdk8 = () -> System.out.println("JDK8 之后的线程创建");
new Thread(runnable1Jdk8).start();
// 更加紧凑的方式
new Thread(() -> System.out.println("JDK8 之后的线程创建")).start();
}
可以发现 Java 8 中的 Lambda 碰到了函数接口 Runnable，自动推断了要运行的 run 方法，不仅省去了 run 方法的编写，也代码变得更加紧凑。
运行得到结果如下。
JDK8 之前的线程创建
JDK8 之后的线程创建
JDK8 之后的线程创建
上面的 Runnable 函数接口里的 run 方法是没有参数的情况，如果是有参数的，那么怎么使用呢？我们编写一个函数接口，写一个 say 方法接受两个参数。
/**
* 定义函数接口
*/
@FunctionalInterface
public interface FunctionInterfaceDemo {
void say(String name, int age);
}
编写一个测试类。
/**
* 函数接口，Lambda 测试
*/
@Test
public void functionLambdaTest() {
FunctionInterfaceDemo demo = (name, age) -> System.out.println("我叫" + name + "，我今年" + age + "岁了");
demo.say("金庸", 99);
}
输出结果。
我叫金庸，我今年99岁了。
3.2 对于方法引用
方法引用这个概念前面还没有介绍过，方法引用可以让我们直接访问类的实例或者方法，在 Lambda 只是执行一个方法的时候，就可以不用 Lambda 的编写方式，而用方法引用的方式：实例/类::方法。这样不仅代码更加的紧凑，而且可以增加代码的可读性。
通过一个例子查看方法引用。
@Getter
@Setter
@ToString
@AllArgsConstructor
static class User {
private String name;
private Integer age;
}
public static List<User> userList = new ArrayList<User>();
static {
userList.add(new User("A", 26));
userList.add(new User("B", 18));
userList.add(new User("C", 23));
userList.add(new User("D", 19));
}
/**
* 测试方法引用
*/
@Test
public void methodRef() {
User[] userArr = new User[userList.size()];
userList.toArray(userArr);
// User::getAge 调用 getAge 方法
Arrays.sort(userArr, Comparator.comparing(User::getAge));
for (User user : userArr) {
System.out.println(user);
}
}
得到输出结果。
Jdk8Lambda.User(name=B, age=18)
Jdk8Lambda.User(name=D, age=19)
Jdk8Lambda.User(name=C, age=23)
Jdk8Lambda.User(name=A, age=26)
3.3 对于遍历方式
Lambda 带来了新的遍历方式，Java 8 为集合增加了 foreach 方法，它可以接受函数接口进行操作。下面看一下 Lambda 的集合遍历方式。
/**
* 新的遍历方式
*/
@Test
public void foreachTest() {
List<String> skills = Arrays.asList("java", "golang", "c++", "c", "python");
// 使用 Lambda 之前
for (String skill : skills) {
System.out.print(skill+",");
}
System.out.println();
// 使用 Lambda 之后
// 方式1,forEach+lambda
skills.forEach((skill) -> System.out.print(skill+","));
System.out.println();
// 方式2，forEach+方法引用
skills.forEach(System.out::print);
}
运行得到输出。
java,golang,c++,c,python,
java,golang,c++,c,python,
javagolangc++cpython
3.4 对于流式操作
得益于 Lambda 的引入，让 Java 8 中的流式操作成为可能，Java 8 提供了 stream 类用于获取数据流，它专注对数据集合进行各种高效便利操作，提高了编程效率，且同时支持串行和并行的两种模式汇聚计算。能充分的利用多核优势。
流式操作如此强大， Lambda 在流式操作中怎么使用呢？下面来感受流操作带来的方便与高效。
流式操作一切从这里开始。
// 为集合创建串行流
stream()
// 为集合创建并行流
parallelStream()
流式操作的去重 distinct和过滤 filter。
@Test
public void streamTest() {
List<String> skills = Arrays.asList("java", "golang", "c++", "c", "python", "java");
// Jdk8 之前
for (String skill : skills) {
System.out.print(skill + ",");
}
System.out.println();
// Jdk8 之后-去重遍历
skills.stream().distinct().forEach(skill -> System.out.print(skill + ","));
System.out.println();
// Jdk8 之后-去重遍历
skills.stream().distinct().forEach(System.out::print);
System.out.println();
// Jdk8 之后-去重，过滤掉 ptyhon 再遍历
skills.stream().distinct().filter(skill -> skill != "python").forEach(skill -> System.out.print(skill + ","));
System.out.println();
// Jdk8 之后转字符串
String skillString = String.join(",", skills);
System.out.println(skillString);
}
运行得到结果。
java,golang,c++,c,python,java,
java,golang,c++,c,python,
javagolangc++cpython
java,golang,c++,c,
java,golang,c++,c,python,java
流式操作的数据转换（也称映射）map。
/**
* 数据转换
*/
@Test
public void mapTest() {
List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5);
// 数据转换
numList.stream().map(num -> num * num).forEach(num -> System.out.print(num + ","));
System.out.println();
// 数据收集
Set<Integer> numSet = numList.stream().map(num -> num * num).collect(Collectors.toSet());
numSet.forEach(num -> System.out.print(num + ","));
}
运行得到结果。
1,4,9,16,25,
16,1,4,9,25,
流式操作的数学计算。
/**
* 数学计算测试
*/
@Test
public void mapMathTest() {
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
IntSummaryStatistics stats = list.stream().mapToInt(x -> x).summaryStatistics();
System.out.println("最小值：" + stats.getMin());
System.out.println("最大值：" + stats.getMax());
System.out.println("个数：" + stats.getCount());
System.out.println("和：" + stats.getSum());
System.out.println("平均数：" + stats.getAverage());
// 求和的另一种方式
Integer integer = list.stream().reduce((sum, cost) -> sum + cost).get();
System.out.println(integer);
}
运行得到结果。
得到输出
最小值：1
最大值：5
个数：5
和：15
平均数：3.0
15
4. Lambda 总结
Lamdba 结合函数接口，方法引用，类型推导以及流式操作，可以让代码变得更加简洁紧凑，也可以借此开发出更加强大且支持并行计算的程序，函数编程也为 Java 带来了新的程序设计方式。但是缺点也很明显，在实际的使用过程中可能会发现调试困难，测试表示 Lamdba 的遍历性能并不如 for 的性能高，大家酌情选用。
扫一扫
297
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
