二 Lambda语法

在讲解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接口中定义了不止一个抽象方法会怎样呢？可以看到使用会报错：

1554908675(1).jpg

Java8提供了一个@FunctionalInterface注解，用来标注某个接口是函数式接口，保证该接口只能有一个抽象方法，如下函数式接口定义两个抽象方法就会报错：

ss.jpg

介绍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内置的四大核心函数式接口