Lambda（一）

Lambda简介

Lambda 可定义为一种简洁、可传递的匿名函数，它是推动Java 8发布的最重要新特性
Lambda 本质上是一个函数，虽然它不属于某个特定的类，但具备参数列表、函数主体、返回类型，甚至能够抛出异常
Lambda 是匿名的，它没有具体的函数名称
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）
Lambda 可以使代码变的更加简洁

基本语法

参数列表 -> 表达式
参数列表 -> {表达式集合}
需要注意的是 lambda 表达式默认隐含了 return 关键字，在单个表达式中，我们无需在写 return 关键字，也无需写花括号。
只有当表达式是一个集合的时候，才需要写花括号及 return 关键字

代码示例

// 返回给定字符串的长度（隐含return语句）
(String str) -> str.length()
// 始终返回233的无参方法（隐含return语句）
() -> 233
// 返回当前用户是否年龄大于20岁，返回一个boolean值（隐含return语句）
(User user) -> user.getAge() > 20
// 包含多行表达式，需用花括号括起来，并使用return关键字返回
(int x, int y) -> {
    int z = x * y;
    return x + z;
}

使用Lambda与传统写法对比

//使用Lambda
Runnable r1 = () -> System.out.println("Hello World 1");
//传统匿名类
Runnable r2 = new Runnable(){
    public void run(){
    System.out.println("Hello World 2");
    }
};
//执行Runnable方法
public static void process(Runnable r){
    r.run();
}
//打印 "Hello World 1"
process(r1);
//打印 "Hello World 2"
process(r2);
//利用直接传递的 Lambda 打印 "Hello World 3"
process(() -> System.out.println("Hello World 3"));

Lambda 受检异常处理

简介

Lambda 表达式利用函数式编程提供精简的方式表达行为。
然而，JDK函数式接口没有很好地处理异常，使得处理异常代码非常臃肿和麻烦。
下面我们来探讨下 Lambda 表达式中处理异常的解决方案

代码示例

首先我们看一段简单的代码，将50与List中每个元素相除并打印出结果

List integers = Arrays.asList(1, 2, 3, 4, 5, 6);
integers.forEach(i -> System.out.println(50 / i));

这样看是不会有问题的，代码简洁。
但是如果List中包含元素 0 ，那么就会抛出异常： ArithmeticException: / by zero
有经验的小伙伴可能会立马给出解决方案，使用传统的try-catch来处理异常，代码如下：

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 0);
integers.forEach(i -> {
    try {
        System.out.println(50 / i);
    } catch (ArithmeticException e) {
        System.err.println( "Arithmetic Exception occured : " + e.getMessage());
    }
});

使用try-catch解决了问题，但是失去了lambda表达式的精简，代码变得臃肿，想必并不是完美的解决方案。
对于一些强迫症老哥来说，这种代码是绝对不能存活的，所以我们需要如下的解决方案。

解决方案

我们将会对抛出异常的函数进行包装，使其不抛出受检异常
如果一个 FunctionInterface 的方法会抛出受检异常（比如 Exception ），那么该
FunctionInterface 便可以作为会抛出受检异常的 Lambda 的目标类型。
我们定义如下一个 FunctionInterface ：

@FunctionalInterface
interface UncheckedFunction<T, R> {
    R apply(T t) throws Exception;
}

那么该 FunctionInterface 便可以作为抛出受检异常的 Lambda 的目标类型，此时 Lambda 中并不需要捕获异常，因为目标类型的 apply 方法已经将异常抛出了。

我们如何使用 UncheckedFunction 到流式操作的 Lambda 中呢？
首先我们定义一个 Try 类，它的 of 方法提供将 UncheckedFunction 包装为 Function 的功能：

public class Try {
    public static <T, R> Function<T, R> of(UncheckedFunction<T, R> mapper) {
        Objects.requireNonNull(mapper);
        return t -> {
            try {
                return mapper.apply(t);
            } catch (Exception e) {
                throw Exceptions.unchecked(e);
            }
        };
    }
    @FunctionalInterface
    public interface UncheckedFunction<T, R> {
        R apply(T t) throws Exception;
    }
}

然后在原先的代码中，我们使用 Try.of 方法来对会抛出受检异常的 Lambda 进行包装：

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5, 6, 0);
integers.forEach(Try.of(i -> System.out.println(50 / i)));

此时，我们便可以选择是否去捕获异常（ RuntimeException ）。这种解决方法下，我们一般不关心抛出异常的情况 。 比如自己写的小例子，抛出了异常程序就该终止；或者你知道这个 Lambda 确实 100% 不会抛出异常。