Lambda表达式与函数式接口

Lambda简介

在创建匿名内部类的过程中，你是否觉得代码冗余繁长？为了运行类内的方法，而不得不创建一个匿名内部类来调用方法，这在面向对象的Java中无可厚非，但是不是有更简单直接的写法呢？

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。Lambda 表达式更倾向于函数式编程的思想，即强调做什么，而不是以什么形式做。

语法形式：(参数类型 参数名称) ‐> { 代码语句 }

函数式编程实例

让我们来定义一个Person类，创建几个对象并按照年龄升序排列

public class Person{
    private String name;
    private int age;
}

完成年龄升序排序

import java.util.Arrays;
import java.util.Comparator;
public class Demo06Comparator {
    public static void main(String[] args) {
//创建Person数组，添加Person类对象
        Person[] array = {
                new Person("A", 19),
                new Person("B", 30),
                new Person("B", 25) };
// 匿名内部类,Comparator接口内的compare方法实现排序
        Arrays.sort(array, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge() ‐ o2.getAge();
            }
        };);
        for (Person person : array) {
            System.out.println(person);
        }
    }
}

在上例中，我们需要使用Comparator接口内的compare方法，因此创建了Comparator的匿名内部类，导致代码比较复杂。那么，我们将如何使用Lambda表达式进行优化呢？

import java.util.Arrays;
public class Demo07ComparatorLambda {
    public static void main(String[] args) {
        Person[] array = {
                new Person("A", 19),
                new Person("B", 18),
                new Person("C", 25) };
        Arrays.sort(array, (Person a, Person b) ‐> {
            return a.getAge() ‐ b.getAge();
        });
        for (Person person : array) {
            System.out.println(person);
        }
    }
}

从上例可以看出，Lambda表达式就是对行为进行参数化处理，让函数仅保留模板代码。

Lambda省略格式

Lambda强调的是“做什么”而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。

1、小括号内参数的类型可以省略；
2、如果小括号内有且仅有一个参，则小括号可以省略；
3、如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

Lambda使用前提

1、使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法（即函数式接口）。 无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一 时，才可以使用Lambda。
2、使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
3、lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
4、lambda 表达式的局部变量可以不用声明为 final，但是必须不可被后面的代码修改（即隐性的具有 final 的语义）

int num = 1;  
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
num = 5;  
//报错信息：Local variable num defined in an enclosing scope must be final or effectively

5、在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。例如

String first = "";  
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错

常用的函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导（Lambda 表达式通常用来取代匿名内部类，但二者在原理上是不同的）

tips：Java 8中专门为函数式接口引入了一个新的注解@FunctionalInterface ，该注解可用于一个接口的定义上。一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。

JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，它们主要在 java.util.function 包中被提供。

1、Supplier接口
java.util.function.Supplier 接口仅包含一个无参的方法：T get() 。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。

import java.util.function.Supplier;
public class Demo08Supplier {
    private static String getString(Supplier<String> function) {
        return function.get();        }
    public static void main(String[] args) {
        String msgA = "Hello";
        String msgB = "World";
        System.out.println(getString(() ‐> msgA + msgB));
    } }

在上例中，通过get方法获取了一个拼接的字符串。

2、Consumer接口
java.util.function.Consumer 接口则正好与Supplier接口相反，它不是生产一个数据，而是使用一个数据， 其数据类型由泛型决定。Consumer 接口中包含抽象方法 void accept(T t) ，意为使用一个指定泛型的数据。

import java.util.function.Consumer;   
public class Demo09Consumer {     
private static void consumeString(Consumer<String> function) {        
function.accept("Hello"); }      
public static void main(String[] args) {         
consumeString(s ‐> System.out.println(s));
}
}

3、Predicate接口
java.util.function.Predicate 接口可以对某种类型的数据进行判断，从而得到一个boolean值结果。Predicate 接口中包含一个抽象方法： boolean test(T t) ，用于条件判断的场景。

import java.util.function.Predicate;   
public class Demo15PredicateTest {    
private static void method(Predicate<String> predicate) {        
boolean veryLong = predicate.test("HelloWorld");         
System.out.println("字符串长度是否大于5：" + veryLong); }      
public static void main(String[] args) {method(s ‐> s.length() > 5); 
}
}