【JAVA8新特性】- Lambda表达式

先来个例子热身：

        // java8中增强的Comparator
        List list = new ArrayList<>();

        list.add(12.3);
        list.add(13.3);
        list.add(14.3);
        list.add(15.3);
        list.add(16.3);
        list.add(10.3);

        // 使用Comparator接口对其从小到大排序：
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Double o1, Double o2) {
                return o1.compareTo(o2);
            }
        });

        // Comparator接口是一个函数式接口，函数描述为(T,T)->int，java8中可以使用Lambda改造上面的方法
        Collections.sort(list, (o1, o2) -> o1.compareTo(o2));

        // Java8对list 提供了sort方法，可以代替Comparator.sort
        list.sort((o1, o2) -> o1.compareTo(o2));

        // 方法进一步简化
        list.sort(Double::compareTo);

        // java8对Comparator 增加了reversed 结果反转
        Comparator comparator = Double::compareTo;
        list.sort(comparator.reversed());

        list.forEach(e -> System.out.print(e + "   "));

下面来了解Lambda

Java 8的Lambda表达式借鉴了C#和Scala等语言中的类似特性，简化了匿名函数的表达方式。

Lambda表达式可以直接以内联的形式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例。

什么是函数式接口？简单来说就是只包含一个抽象方法的接口，允许有默认的实现（使用default关键字描述方法）。函数式接口建议使用@FunctionalInterface注解标注，虽然这不是必须的，但是这样做更符合规范。
在Java8之前，实现Runnable常用方式是编写一个匿名类：

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
        thread.start();

使用Lambda表达式后，上面的代码可以改造为：

        Thread thread = new Thread(() -> System.out.println("hello"));
        thread.start();

Lambda表达式解析

Lambda表达式的基本语法如下：

(parameters) -> expression 
or
(parameters) -> { statements; }

由语法可以看到，Lambda表达式包含了三个部分：

1. 参数列表；
2. 箭头->把参数列表与Lambda主体分隔开；
3. Lambda主体，只有一行代码的时候可以省略大括号和return关键字。

比如下面这些Lambda表达式都是合法的：

(String str) -> str.length()
(String str) -> { return str.length(); }

() -> System.out.println("hello")

() -> {}
() -> 17

(int x, int y) -> {
    System.out.println(x);
    System.out.println(y);
}

Lambda的使用场合

什么时候可以使用Lambda表达式？使用Lambda必须满足以下两个条件：

1. 实现的对象是函数式接口的抽象方法
2. 函数式接口的抽象方法的函数描述符合lambda表达式的函数描述一致

---

函数式接口
在Java 8之前，常见的函数式接口有java.util.Comparator，java.lang.Runnable等。拿java.util.Runnable来说，查看其源码如下：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

这个接口只有一个抽象方法，并且使用@FunctionalInterface注解标注。

接口现在还可以拥有默认方法（即在类没有对方法进行实现时，其主体为方法提供默认实现的方法）。哪怕有很多默认方法，只要接口只定义了一个抽象方法，它就仍然是一个函数式接口。

函数描述符
函数描述符其实也可以理解为方法的签名。比如上述的Runnable抽象方法不接受参数，并且返回void，所以其函数描述符为() -> void。而() -> System.out.println("hello")Lambda表达式也是不接受参数，并且返回void，即其函数描述符也是() -> void。所以代码Runnable r = () -> System.out.println("hello");是合法的。

特殊的void兼容规则
如果一个Lambda的主体是一个语句表达式， 它就和一个返回void的函数描述符兼容（当然需要参数列表也兼容）。例如，以下Lambda是合法的，尽管List的add方法返回了一个 boolean，而不是Runnable抽象方法函数描述符() -> void所要求的void：

List list = new ArrayList<>();
Runnable r = () -> list.add("hello");

更简洁的Lambda

普通引用，方法的引用，构造函数的引用

编写一个类型转换的函数值接口：

@FunctionalInterface
public interface TransForm {

    R trandForm(T t);
}

编写一个Lambda表达式实现该函数式接口，用于实现String转换为Integer，代码如下：

        TransForm transForm = (String str) -> Integer.valueOf(str);
        System.out.println(transForm.trandForm("123"));

上面的Lambda表达式可以进一步简化为如下方式：

TransForm t = (str) -> Integer.valueOf(str);
System.out.println(t.transForm("123"));

因为Java编译器会从上下文（目标类型）推断出用什么函数式接口来配合Lambda表达式，这意味着它也可以推断出适合Lambda的签名。就拿这个例子来说，TransForm的抽象方法transForm在本例中的函数描述符为(String) -> Integer，所以对应的Lambda的签名也是如此，即Lambda的参数即使不声名类型，Java编译器可以知道其参数实际上为String类型。

其实，上面的Labmda表达式还不是最简洁的，其还可以更进一步地简化为如下写法：

TransForm t = Integer::valueOf;
System.out.println(t.transForm("123"));

你肯定很困惑，这还是Lambda表达式吗，箭头去哪里了？双冒号又是什么鬼？其实这种写法有一个新的名称，叫做方法的引用。

方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法。它的基本思想是，如果一个Lambda代表的只是“直接调用这个方法”，那最好还是用名称来调用它，而不是去描述如何调用它，这样代码可读性更好。基本写法就是目标引用放在分隔符::前，方法的名称放在后面。

举几个Lambda及其等效方法引用的例子：\

Lambda表达式	等效方法引用
(String s) -> System.out.println(s)	System.out::println
(str, i) -> str.substring(i)	String::substring
() -> Thread.currentThread().dumpStack()	Thread.currentThread()::dumpStack

符号::除了出现在方法的引用外，它还常见于构造函数的引用中。为了演示什么是构造函数的引用，我们创建一个新的函数式接口：

@FunctionalInterface
public interface Generator {
    R create(T t);
}

创建一个Apple类：

public class Apple {

    public Apple(String color) {
        this.color = color;
    }

    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

现在我们可以使用如下方式来创造一个Apple实例：

        TransForm2 transForm3 = Apple::new;
        Apple greenApple = transForm3.create("green");

这种通过ClassName::new的写法就是构造函数的引用。在这里Generator的抽象方法接收一个String类型参数，返回值类型为Apple，这和Apple类的构造函数相符合，所以这里编译可以通过。它等价于下面的写法：

        TransForm2 transForm4 = (String str) -> new Apple(str);
        Apple greenApple2 = transForm4.create("green");

Lambda表达式访问变量

Lambda表达式可以访问局部final变量，成员变量和静态变量。

这里主要说下局部final变量。有无final关键字不重要，重要的是确保该变量的值不会被改变就行了。比如下面的例子可以编译通过：

        String hello = "Hello python";
        Runnable r = ()->System.out.println(hello);

而下面的这个就会编译出错，因为变量hello的值被改变了：

image.png

Lambda表达式实战

定义实体类Person

public class Person {

    public Person(String name, int age, int height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    private String name;
    private int age;
    private int height;
    ......

定义筛选接口(筛选接口)

@FunctionalInterface
public interface PersonFilter {

    boolean isChoose(Person person);
}

定义筛选方法：

public class PersonFilterMethod {

    public static List filterPersons(List persons, PersonFilter personFilter) {
        List choosePersons = new ArrayList<>();
        for (Person person : persons) {
            if (personFilter.isChoose(person)) {
                choosePersons.add(person);
            }
        }
        return choosePersons;
    }
}

筛选年龄大于25的Person

        Person person1 = new Person("python", 25, 60);
        Person person2 = new Person("java", 26, 70);
        Person person3 = new Person("php", 27, 80);
        Person person4 = new Person("js", 28, 90);

        List persons = new ArrayList<>();
        persons.add(person1);
        persons.add(person2);
        persons.add(person3);
        persons.add(person4);

        List filterPersons = PersonFilterMethod.filterPersons(persons, person -> person.getAge() > 25);

筛选年龄大于25，身高大于80的Person

 List people = PersonFilterMethod.filterPersons(persons, person -> (person.getAge() > 25 && person.getHeight() > 80));

参考博文：https://mrbird.cc/java8lambda1.html