Java Lambda表达式

Lambda表达式

简介

​ Lambda是一种可传递的匿名函数，可以作为参数传递给方法或存储在变量中，在需要的时候调用它们。

​ 主要目的，简化Java代码，便于阅读和编写

语法

​ 由参数列表，箭头符号，方法体组成。

参数列表 -> 表达式
参数列表 -> {表达式集合}

​ 参数列表指定传递给Lambda表达式的参数

​ 箭头符号 “->” 分隔参数列表和方法体

​ 方法体则包含Lambda表达式要执行的代码

注意：

lambda表达式默认隐含了return关键字。

1. 在单个表达式中，无需写return关键字和花括号。
2. 表达式是一个集合时，才需要写花括号及return关键字

示例

// 始终返回5的无参方法（隐含return语句） 
() -> 5  

// 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  

// 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  

// 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

// 返回当前用户是否年龄大于20岁，返回一个boolean值（隐含return语句）
(User user) -> user.getAge() > 20

// 包含多行表达式，需用花括号括起来，并使用return关键字返回
(int x, int y) -> {
    int z = x * y;
    return x + z;
}

public class JavaTest {
   public static void main(String args[]){
      JavaTest tester = new JavaTest();
        
      // 类型声明
      MathOperation addition = (int a, int b) -> a + b;
        
      // 不用类型声明
      MathOperation subtraction = (a, b) -> a - b;
        
      // 大括号中的返回语句
      MathOperation multiplication = (int a, int b) -> { return a * b; };
        
      // 没有大括号及返回语句
      MathOperation division = (int a, int b) -> a / b;
        
      System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
      System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
      System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
      System.out.println("10 / 5 = " + tester.operate(10, 5, division));
        
      // 不用括号
      GreetingService greetService1 = message ->
      System.out.println("Hello " + message);
        
      // 用括号
      GreetingService greetService2 = (message) ->
      System.out.println("Hello " + message);
        
      greetService1.sayMessage("Runoob");
      greetService2.sayMessage("Google");
   }
    
   interface MathOperation {
      int operation(int a, int b);
   }
    
   interface GreetingService {
      void sayMessage(String message);
   }
    
   private int operate(int a, int b, MathOperation mathOperation){
      return mathOperation.operation(a, b);
   }
}

public static void main(String args[]) {
    //使用Lambda
    Runnable r1 = () -> System.out.println("Hello World 1");
    //传统匿名类
    Runnable r2 = new Runnable(){
        public void run(){
            System.out.println("Hello World 2");
        }
    };

    //打印 "Hello World 1"
    process(r1);
    //打印 "Hello World 2"
    process(r2);
    //利用直接传递的 Lambda 打印 "Hello World 3"
    process(() -> System.out.println("Hello World 3"));
}

//执行Runnable方法
public static void process(Runnable r){
    r.run();
}

进阶示例

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 ：

apply方法，接收一个参数T，计算后返回结果值R

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

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

我们如何使用 UncheckedFunction 到流式操作的 Lambda 中呢？

首先我们定义一个 Try 类，它的 of 方法提供将 UncheckedFunction 包装为 Function 的功能：

of 方法，入参是一个接口函数（可以传lambda），方法体也是一个匿名函数（lambda），所以返回参数是<T, R> Function<T, R>

逻辑：输入一个参数，进行计算并处理异常，最后返回结果

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% 不会抛出异
常。

总结

​ 入参出参都是lambda，中间方法体进行了包装。例如方法体处理异常，或者又进行其它复杂计算

注意

1. 实现的接口，只能包含一个抽象方法方法。如果存在多个，在使用lambda时，不知道实现那个方法，会报错。
2. lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。（参考匿名类对局部变量的调用，匿名类只是得到外部局部变量的副本）