java8新特性3--lambda表达式

2017-04-28 本文已影响161人不迷失

行为参数化

lambda

开发中，经常需要给一个方法传递一个接口类型的参数，为了传递不同的行为，我们需要创建不同的实现类，而通常这些类没什么重用价值，只使用一次就没用了。

考虑一个从一堆苹果中筛选符合条件的苹果的场景。

为了更好的应对需求变更，一个比较好的解决办法是将过滤的标准抽象出来，我们先定义一个接口作为抽象的选择标准.

public interface ApplePredicate{
    boolean test(Apple apple);
}

接下来就可以定义多个ApplePredicate接口的实现类来代表不同的过滤标准。

public class AppleHeavyWeightPredicate implements ApplePredicate{ 
    public boolean test(Apple apple){
        return apple.getWeight() > 150;
    }
}

//select only green apple
public class AppleGreenColorPredicate implements ApplePredicate{ 
    public boolean test(Apple apple){
        return "green".equals(apple.getColor);
    }
}

上面每一个实现了ApplePredicate接口的类都代表了一种筛选策略。

在此基础上，我们可以将筛选方法修改成下面的样子,将ApplePredicate作为参数传入。这就是所谓的行为参数化。

public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate p){
    List<Apple> result = new ArrayList<>();
    for(Apple apple : inventory){
        if(p.test(apple)){
            result.add(apple);
        }
    }
    return result;
}

现在的筛选方法很灵活，如果想改变筛选标准，只需创建不同的ApplePredicate对象，并传入filterApples方法即可。

例如新增了选出红色并且重量大于150g的苹果的需求，我们可以创建一个实现ApplePredicate接口的类即可，代码如下:

public class AppleRedAndHeavyPredicate implements ApplePredicate{
    public boolean test(Apple apple){
        return "red".equals(apple.getColor()) && apple.getWeight() > 150;
    }
}
 
List<Apple> redAndHeavyApples = filter(inventory, new AppleRedAndHeavyPredicate());

但是上面的实现有一个缺点，就是太啰嗦了，每新增一个筛选标准都要新增一个类。下面来继续优化一下。

使用匿名类

匿名类是没有名字的类，使用匿名类可以创建一个临时的实现。下面的代码展示了如何利用匿名类创建实现了ApplePredicate的对象。

List<Apple> redApples = filterApples(inventory, new ApplePredicate(){
    public boolean test(Apple apple){
        return "red".equals(apple.getColor());
    }
});

但是尽管匿名类解决了为一个接口声明多个实现类的问题，使用匿名类还不足够好。使用匿名类代码看起来有些笨重，可读性差，而且有一些开发者对匿名类感到困惑。

Lambda

Java 8中推出了解决这个问题的新工具——Lambda表达式。它可以让你很简洁地表示一个行为或传递代码。

可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式:它没有名称，但它有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。

匿名——我们说匿名，是因为它不像普通的方法那样有一个明确的名称!
函数——我们说它是函数，是因为Lambda函数不像方法那样属于某个特定的类。但和方法一样，Lambda有参数列表、函数主体、返回类型，还可能有可以抛出的异常列表。
传递——Lambda表达式可以作为参数传递给方法或存储在变量中。
简洁——无需像匿名类那样写很多模板代码。

利用Lambda 表达式，你可以更为简洁地自定义一个Comparator对象。

先前:

 Comparator<Apple> byWeight = new Comparator<Apple>() {
    public int compare(Apple a1, Apple a2){
        return a1.getWeight().compareTo(a2.getWeight());
    }; 
 }

用了Lambda表达式后:

 Comparator<Apple> byWeight =
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

不得不承认，代码看起来更清晰了!

Lambda 表达式的结构

上面的Lambda表达式我们可以将其分解成三个部分:

参数列表——这里它采用了Comparator中compare方法的参数，两个Apple。
箭头—— 箭头->把参数列表与Lambda主体分隔开。
Lambda主体——a1.getWeight().compareTo(a2.getWeight())，表达式就是Lambda的返回值。

以下是一些 Lambda 表达式的例子：

(int a, int b) -> {  return a + b; }

() -> System.out.println("Hello World");

(String s) -> { System.out.println(s); }

() -> 42

() -> { return 3.1415 };

Runnable run= () -> System.out.println("Hello World");

Lambda表达式的特点：

一个 Lambda 表达式可以有零个或多个参数
参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同
所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)
空圆括号代表参数集为空。例如：() -> 42
当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> a*a
Lambda 表达式的主体可包含零条或多条语句
如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。
匿名函数的返回类型与该主体表达式一致
如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。
表达式就是Lambda的返回值，意味着你无需写return，若表达式没有返回则为空
可以显示的通过return关键字返回值，但必须将主体写在{}中，如(Integer i) -> return "Alan" + i;是错误的写法
Lambda表达式可以用变量接收。

在哪里以及如何使用Lambda

现在你可能在想，在哪里可以使用Lambda表达式。在上一个例子中，你把Lambda赋给了一
个Comparator<Apple>类型的变量。

你也可以在上面的filter方法中使用Lambda:

List<Apple> greenApples =
filter(inventory, (Apple a) -> "green".equals(a.getColor()));

事实上，你可以在函数式接口上使用Lambda表达式。

函数式接口

函数式接口就是只定义了一个抽象方法的接口。像Java中的Runnable,Comparator等等都只定义了一个方法，这种接口就都是函数式接口。

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

继承了其他接口的接口，如果它总共的抽象方法不止一个，也不是函数式接口。

Lambda表达式允许你直接以内联的形式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例(具体说来，是函数式接口一个具体实现的实例)。你用匿名内部类也可以完成同样的事情，只不过比较笨拙:需要提供一个实现，然后再直接内联将它实例化。

请注意，任何函数式接口都不允许抛出受检异常(checked exception)。如果你需要Lambda
表达式来抛出异常，有两种办法:定义一个自己的函数式接口，并声明受检异常，或者把Lambda 包在一个try/catch块中。

示例：

//旧方法:
new Thread(new Runnable() {
@Override
public void run() {
    System.out.println("Hello from thread");
}
}).start();

//新方法:
new Thread(
() -> System.out.println("Hello from thread")
).start();

@FunctionalInterface

如果你去看看新的Java API，会发现函数式接口带有@FunctionalInterface的标注.

这个标注用于表示该接口会设计成一个函数式接口。

如果你用@FunctionalInterface定义了一个接口，而它却不是函数式接口的话，编译器将返回一个提示原因的错误,表明存在多个抽象方法。请注意，@FunctionalInterface不是必需的，但对于为此设计的接口而言，使用它是比较好的做法。它就像是@Override 标注表示方法被重写了。

我相信，从此你会对Lambda爱不释手的，赶紧用起来吧。