目录
前言
Java8既JDK1.8。
Lambda表达式是Java8的新特性，除此之外Java8还提供了其他新特性，比如：函数式编程、方法引用、Stream、Optional类、默认方法、新的日期类型、Base64、Nashorn, JavaScript 引擎。
本篇详细介绍Lambda表达式，其他请参考后续文章。
Lambda是一个语法糖，糖是甜的，但是对于初学者并不是，当你熟悉之后，你会发现，它是真的香。
Lambda表达式的初衷是，进一步简化匿名类的语法，使Java走向函数式编程。不过实现上，Lambda表达式并不是匿名类的语法糖。
1、实现接口的几种方式
方式一：单写一个类来实现接口
方式二：匿名内部类实现接口，重用性不是很高的情况下用。
方式三：Lambda表达式
// 定义一个接口
public interface TestInterface {
void testMethod();
}
// 实现类
class MyClass implements TestInterface {
@Override
public void testMethod() {
System.out.println("我重新实现了testMethod方法！");
}
}
class Demo {
public static void main(String[] args) {
// 方式一：创建接口对应的实现类的对象
TestInterface t = new MyClass();
t.testMethod();
// 方式二：匿名内部类
TestInterface t2 = new TestInterface() {
@Override
public void testMethod() {
System.out.println("我重写了testMethod方法，匿名内部类的方式！");
}
};
t2.testMethod();
// 方式三：lambda
TestInterface t3 = () -> System.out.println("这个是lambda表达式的实现方式");
}
}
看下执行结果：
我重新实现了testMethod方法！
我重写了testMethod方法，匿名内部类的方式！
这个是lambda表达式的实现方式
是不是感觉lamda表达是更加简单了？
现在我们简单总结下：
1、 Lambda 表达式，也可称为闭包，是一种语法结构，是Java8发布的最重要新特性。
2、 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
3、使用 Lambda 表达式可以使代码变得更加简洁紧凑。并没有提升性能。
4、本质：接口的实现类的具体对象
5、应用场合：复用性没有那么强的场景
2、Lambda语法
(parameters) -> expression
或
(parameters) ->{ statements; }
分三部分：
a) -> ：我们称之为“箭头操作符”或“lambda操作符”
b) -> 左侧：
lambda的形参列表，等效于 对应的接口的那个抽象方法的形参列表，例子中testMethod方法没有参数。
可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
c) -> 右侧：
抽象方法的方法体
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式，return关键词可以省略。
3、Lambda使用案例
3.1 无参、无返回值
/**
* 无参、无返回值
*/
interface TestInterface01 {
void testMethod();
}
class Test01 {
public static void main(String[] args) {
TestInterface01 t1 = () -> {
System.out.println("这是一个无参的，无返回值的方法");
};
// 方法体只有一行{}可以省略
TestInterface01 t2 = () -> System.out.println("这是一个无参的，无返回值的方法");
t1.testMethod();
t2.testMethod();
}
}
3.2 有一个参数，无返回值
/**
* 有一个参数，无返回值
*/
interface TestInterface02 {
void testMethod(int num);
}
class Test02 {
public static void main(String[] args) {
TestInterface02 t1 = (int num) -> System.out.println("这是有一个参数的实现：" + num);
// 1、参数名字可以随便起
TestInterface02 t2 = (int x) -> System.out.println("这是有一个参数的实现：" + x);
// 2、 参数的类型可以省略 -》 上下文的类型推断：比如下方的list 和 int数组
List<String> list1 = new ArrayList<String>();
List<String> list2 = new ArrayList<>();
int[] arr1 = new int[]{1, 2, 3, 4};
int[] arr2 = {1, 2, 3, 4};
TestInterface02 t3 = (x) -> System.out.println("这是有一个参数的实现：" + x);
// 3、只有一个参数的话，() 可以省略
TestInterface02 t4 = x -> System.out.println("这是有一个参数的实现：" + x);
t1.testMethod(10);
t2.testMethod(20);
t3.testMethod(20);
t4.testMethod(20);
}
}
3.3 两个以上参数，有返回值
/**
* 2个以上参数，有返回值
*/
interface TestInterface03 {
int testMethod(int num1, int num2);
}
class Test03 {
public static void main(String[] args) {
// 多个参数，() 不可省略
// 方法体中多条语句，{} 不可省略
TestInterface03 t1 = (x, y) -> {
System.out.println("2个以上参数，有返回值" + x + "---" + y);
return 666;
};
// 如果只有一行,return 可以省略
TestInterface03 t2 = (x, y) -> 666;
System.out.println(t1.testMethod(10, 20));
System.out.println(t2.testMethod(10, 20));
}
}
4、函数式编程
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。
函数式接口可以被隐式转换为 lambda 表达式。
通过注解@FunctionalInterface可以定义一个函数式接口，例：
@FunctionalInterface
interface GreetingService
{
void sayMessage(String message);
}
那么就可以使用Lambda表达式来表示该接口的一个实现(注：JAVA 8 之前一般是用匿名类实现的)：
GreetingService greetService1 = message -> System.out.println("Hello " + message);
函数式接口可以对现有的函数友好地支持 lambda。
JDK 1.8 之前已有函数式接口,比如：
java.lang.Runnable
java.util.concurrent.Callable
JDK 1.8 在java.util.function包下面新增加了许多（43个）函数接口，常用的有：
| 接口 | 描述 |
|---|---|
| boolean Predicate<T> | 断言型接口:接受一个输入参数，返回一个布尔值结果。 |
| Function<T,R> | 函数型接口:接受一个输入参数，返回一个结果。 |
| Supplier<T,R> | 供给型接口:无参数，返回一个结果。 |
| Consumer<T,R> | 消费型接口:代表了接受一个输入参数并且无返回的操作 |
下面我们举例来说明怎么使用。
5、函数式编程示例
5.1 不使用内置接口，消费型接口示例
我们自己定义了一个消费型的接口。
// 如果不使用内置函数接口，消费型接口例子
interface SpendMoney {
void buy(double money);
}
class Test04 {
public static void buySomething(double money, SpendMoney sm) {
sm.buy(money);
}
public static void main(String[] args) {
buySomething(1999, new SpendMoney() {
@Override
public void buy(double money) {
System.out.println("我买了件大衣！！！花了" + money + "元钱");
}
});
}
}
5.2 使用内置函数式接口Consumer示例
已经存在了内置函数式接口，我们就没必要再定义自己的接口，显得多余。
class Test05 {
public static void buySomething(double money, Consumer<Double> sm) {
sm.accept(money);
}
public static void main(String[] args) {
buySomething(999, new Consumer<Double>() {
@Override
public void accept(Double o) {
System.out.println("我买了件大衣！！！花了" + o + "元钱");
}
});
// 用lambda表达优化
buySomething(999, o -> System.out.println("我买了件大衣！！！花了" + o + "元钱"));
}
}
5.3 使用断言型接口示例
Predicate 接口是一个函数式接口，它接受一个输入参数 T，返回一个布尔值结果。
该接口包含多种默认方法来将Predicate组合成其他复杂的逻辑（比如：与，或，非）。
该接口用于测试对象是 true 或 false。
我们可以通过以下实例（Java8Tester.java）来了解函数式接口 Predicate 的使用：
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Java8Tester {
public static void main(String args[]){
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// Predicate<Integer> predicate = n -> true
// n 是一个参数传递到 Predicate 接口的 test 方法
// n 如果存在则 test 方法返回 true
System.out.println("输出所有数据:");
// 传递参数 n
eval(list, n->true);
// Predicate<Integer> predicate1 = n -> n%2 == 0
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n%2 为 0 test 方法返回 true
System.out.println("输出所有偶数:");
eval(list, n-> n%2 == 0 );
// Predicate<Integer> predicate2 = n -> n > 3
// n 是一个参数传递到 Predicate 接口的 test 方法
// 如果 n 大于 3 test 方法返回 true
System.out.println("输出大于 3 的所有数字:");
eval(list, n-> n > 3 );
}
public static void eval(List<Integer> list, Predicate<Integer> predicate) {
for(Integer n: list) {
if(predicate.test(n)) {
System.out.println(n + " ");
}
}
}
}
输出结果：
输出所有数据:
1
2
3
4
5
6
7
8
9
输出所有偶数:
2
4
6
8
输出大于 3 的所有数字:
4
5
6
7
8
9
总结
相信你在工作中肯定是经常使用Lambda表达式的，只有真正了解其语法才能熟能生巧。Jdk版本1.8 以上的高级特性比较多，希望你能多花点时间学习并使用，一定要掌握。
“人生当中成功只是一时的，失败却是主旋律，但是如何面对失败，却把人分成了不同的样子。有的人会被失败击垮，有的人能够不断地爬起来继续向前。真正的成熟，应该并不是追求完美，而是直面自己的缺憾。这，才是生活的本质”
公众号：Java尖子生
[关注公众号免费领取Java学习、面试资料。]
2200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
