Java8是自java5之后最重大的一次更新，它给JAVA语言带来了很多新的特性(包括编译器、类库、工具类、JVM等)，其中最重要的升级是它给我们带来了Lambda表达式和Stream API。
1、什么是Lambda表达式？
Lambda是一个匿名函数，可以理解为是一段可以传递的代码，可以将代码像传递参数、传递数据一样进行传输。使用Lambda表达式，可以写出更加紧凑、更加简洁、更加灵活的代码。
2、使用Lambda的限制条件
Lambda并不是任何地方都可以使用，Lambda表达式需要“函数式接口”的支持。
3、什么是函数式接口？
接口中只有一个抽象方法的接口，称为函数式接口，可以用@FunctionalInterface修饰一下，这里需要注意的是：未使用 @FunctionalInterfaces注解的接口未必就不是函数式接口，一个接口是不是函数式接口的条件只有一条，即接口中只有一个抽象方法的接口(Object类中的方法不算)。而使用@FunctionalInterface注解修饰了的接口就一定是函数式接口，添加@FunctionalInterface注解可以帮助我们检查是否是函数式接口。
JDK中常见的函数式接口有：
@FunctionalInterfacepublic interfaceRunnable {voidrun();
}
@FunctionalInterfacepublic interface Callable{
V call() throws Exception;
}以下接口中虽然有两个方法，但因hashCode()是Object类中的方法，因此该接口也是函数式接口：
@FunctionalInterfacepublic interfaceFuncInterface {voiddoSomething();int hashCode(); //Object类中的方法
}4、Lambda表达式示例
需求一：开启一个线程，在线程中打印出"Hello World"
未使用Lambda表达式时的写法：
public classLambdaTest {public voidprint() {
Thread thread= new Thread(newRunnable() {
@Overridepublic voidrun() {
System.out.println("Hello World");
}
});
thread.start();
} }使用Lambda时的写法：
public classLambdaTest {public voidprint() {
Thread thread= new Thread(() -> System.out.println("Hello World"));
}
}需求二：模拟一个计算器，使其可以进行简单的加、减、乘操作
(1)、计算器操作函数式接口
@FunctionalInterfacepublic interface Calculator{
T operation(T t1,T t2);
}(2)具体操作
public classCalculatorTest {public Integer operator(Integer v1,Integer v2,Calculatorcalculator) {returncalculator.operation(v1,v2);
}publicInteger add(Integer v1,Integer v2) {return operator(v1,v2,(x,y) -> x +y);
}publicInteger subtr(Integer v1,Integer v2) {return operator(v1,v2,(x,y) -> x -y);
}publicInteger multi(Integer v1,Integer v2) {return operator(v1,v2,(x,y) -> x *y);
}public static voidmain(String[] args) {
CalculatorTest calculatorTest= newCalculatorTest();//加法
Integer add = calculatorTest.add(1,2);//减法
Integer sub = calculatorTest.subtr(100,82);//乘法
Integer multi = calculatorTest.multi(5,3);
System.out.println(add);
System.out.println(sub);
System.out.println(multi);
}
}运行结果：
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 classCalculatorTest {
2
3 public void print(Consumermsg) {
4 System.out.println(msg);
5 }
6
7 public voiddoPrint(String msg) {
8 print((str) ->System.out.println(msg));
9 print(str -> System.out.println(msg)); //简写
10
11 }
12 }此时，左边的()可以省略。
5.3 语法格式三：Lambda体内只有一条语句，且有返回值，return可省略
1 publicInteger subtr(Integer v1,Integer v2) {
2 return operator(v1,v2,(x,y) -> x -y);
3 }5.4 语法格式四：有两个以上参数，且Lambda体中有多条语句
1 publicInteger 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 publicInteger subtr(Integer v1,Integer v2) {
2 return operator(v1,v2,(Integer x,y) -> x - y); //错误
3 }
4
5 publicInteger subtr(Integer v1,Integer v2) {
6 return operator(v1,v2,(x,y) -> x - y); //正确
7 }6、Java8四大内置核心函数式接口
Consumer: 消费型接口(无返回值，有去无回)
voidaccept(T t);
Supplier: 供给型接口
T get();
Function: 函数型接口
R apply(T t);
Predicate: 断言型接口
booleantest(T t);四大核心接口的-->扩展子接口
示例：
1 importlombok.Getter;
2 importlombok.Setter;
3
4 importjava.util.function.Consumer;
5 importjava.util.function.Function;
6 importjava.util.function.Predicate;
7 importjava.util.function.Supplier;
8
9 @Getter
10 @Setter
11 classUser {
12 privateString username;
13 private intage;
14
15 @Override
16 publicString toString() {
17 return "User{" +
18 "username='" + username + '\'' +
19 ", age=" + age +
20 '}';
21 }
22 }
23
24 public classInnerInterface {
25
26 /**
27 * 打印user信息
28 */
29 public void print(User user,ConsumeruserConsumer) {
30 userConsumer.accept(user);
31 }
32
33 /**
34 * 返回一个user
35 */
36 public User getUser(SupplieruserSupplier) {
37 returnuserSupplier.get();
38 }
39
40 /**
41 * 转换一个user
42 */
43 public User transformUser(User user,Functionfunction) {
44 returnfunction.apply(user);
45 }
46
47 /**
48 * 检验User是否合法
49 */
50 public boolean checkUser(User user, Predicatepredicate) {
51 returnpredicate.test(user);
52 }
53
54 public static voidmain(String[] args) {
55
56 User userObj = newUser();
57 userObj.setUsername("西门吹雪");
58 userObj.setAge(22);
59
60 //测试Consumer
61 InnerInterface mainInst = newInnerInterface();
62 mainInst.print(userObj,user ->System.out.println(user));
63
64 //测试Supplier
65 final User user1 = mainInst.getUser(() ->{
66 User user = newUser();
67 user.setUsername("叶孤城");
68 user.setAge(22);
69 returnuser;
70 });
71 System.out.println(user1);
72
73 //将西门吹雪的年龄改为25
74 final User user2 = mainInst.transformUser(userObj, (user ->{
75 user.setAge(25);
76 returnuser;
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 voidaccept(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包下，读者可去这个包下去查询。
