在讲解Lambda语法之前我们需要先明确一点：Lambda表达式需要函数式接口的支持。什么是函数式接口？其实就是接口中只能允许有一个抽象方法(可以有默认实现方法)：
public interface MyFunction {
Integer getValue(Integer num);
}
使用：
public Integer operation(Integer num, MyFunction mf){
return mf.getValue(num);
}
@Test
public void test7(){
Integer num = operation(100, (x) -> x * x);
System.out.println(num);
}
如果在MyFunction接口中定义了不止一个抽象方法会怎样呢？可以看到使用会报错：
Java8提供了一个@FunctionalInterface注解，用来标注某个接口是函数式接口，保证该接口只能有一个抽象方法，如下函数式接口定义两个抽象方法就会报错：
介绍Lambda表达式的语法格式之前，我们写一个demo做一个简单的介绍：
Java8之前我们这样创建一个Runnable匿名对象去输出一个值:
@Test
public void test(){
int num = 0;
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(num);
}
};
}
使用Lambda表达式：
@Test
public void test1(){
int num = 0;//JDK1.7之前必须显示声明为final
Runnable r = () -> System.out.println("Hello Lambda!" + num);
}
Java8中引入了一个新的操作符"->" 该操作符称为箭头操作符或Lambda操作符，箭头操作符将Lambda表达式拆分成两部分:
左侧:Lambda表达式的参数列表（对应方法里面的参数列表）
右侧:Lambda表达式中所需执行的功能,即Lambda体（对应方法里面的执行体）
结合我们开篇介绍的函数式接口的概念，我们不难总结出一些规律：对于函数式接口，由于他只有一个抽象方法，当我们需要创建它的匿名对象时，我们的关注点其实只有他的这个抽象方法的实现，甚至于方法叫什么名字我们也不关心。再来看Lambda表达式，我们没有看到new Inteface，没有看到方法名，只有简单的方法参数列表:()和方法体的实现:{}
下面我们介绍Lambda的接种语法格式：
语法格式一:无参数,无返回值
() -> System.out.println("Hello Lambda");
示例代码请参考上面。
语法格式二:一个参数,无返回值
(x) -> System.out.println(x)
示例代码:
@Test
public void test2(){
//传统写法
Consumer<String> con = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("Hello Lambda");
//Lambda
Consumer<String> con1 = (x) -> System.out.println(x);
con1.accept("Hello Lambda");
}
语法格式三:若只有一个参数,小括号可以省略不写
x -> System.out.println(x)
示例代码：
@Test
public void test3(){
Consumer<String> con = x -> System.out.println(x);
con.accept("Hello Lambda");
}
语法格式四:两个以上参数,并且Lambda体中有多条语句,有返回值
(x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
示例代码:
@Test
public void test4(){
Comparator<Integer> com = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println("传统语法");
return Integer.compare(o1,o2);
}
};
Comparator<Integer> com1 = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
}
语法格式五:Lambda体中只有一条语句,return和大括号可以省略不写
示例代码:
@Test
public void test5(){
Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
}
如果你使用的Idea，那么强大的Idea会在这里提示你有更好的写法:
Comparator<Integer> com1 = Integer::compareTo;
当然这是我们后面要介绍的，现在这么写你可能看不懂，简单提一句，治愈强迫症患者。
语法格式六:Lambda表达式的参数列表的数据类型可以省略不写,因为JVM编译器可以通过上下文可以推断出数据类型,即类型推断
(x, y) -> Integer.compare(x, y);
语法介绍完毕，下面来点练习：
创建一个List集合，添加一些数据:
List<Employee> employees = Arrays.asList(
new Employee("张三", 18, 9999.99),
new Employee("李四", 38, 5555.99),
new Employee("王五", 50, 6666.66),
new Employee("赵六", 16, 3333.33),
new Employee("田七", 8, 7777.77)
);
1.调用Collections.sort方法,通过定制排序比较两个Employee( 先按年龄比,年龄相同按姓名比),使用Lambda作为参数传递
@Test
public void test1(){
Collections.sort(employees, (x, y) -> {
if (x.getAge() == y.getAge()) {
return x.getName().compareTo(y.getName());
}
return Integer.compare(x.getAge(), y.getAge());
});
for (Employee e : employees) {
System.out.println(employees);
}
}
2.①声明函数式接口,接口中声明抽象方法:public String getValue(String str)②编写测试方法使用接口作为参数,将一个字符串去除首尾空格并作为方法的返回值
@FunctionalInterface
public interface MyFunction {
String getValue(String str);
}
public String strHandler(String str, MyFunction mf){
return mf.getValue(str);
}
@Test
public void test(){
String st = strHandler(" \t\t\t Hellos ", (str) -> str.trim());
System.out.println(st);
}
3.①声明一个带两个泛型的函数式接口,泛型类型为<T,R> T为参数,R为返回值②接口中声明对应抽象方法③编写测试方法使用接口作为参数,计算两个long类型参数的和
@FunctionalInterface
public interface MyFunction2<T, R> {
R getValue(T t1, T t2);
}
public void op(Long l1, Long l2, MyFunction2<Long, Long> mf){
System.out.println(mf.getValue(l1, l2));
}
@Test
public void test3(){
op(1L, 2L, (x, y) -> x + y);
}
到这我们应该对Lambda有了初步的了解。上面的练习中我们发现每次使用Lambda表达式的时候，都要去写一些函数式接口，未免显得有些麻烦，针对这种情况，Java8已经帮我们内置了一些函数式接口供我们使用，满足我们开发中的大部分需求，在下一篇我们介绍Java8内置的四大核心函数式接口
