在这篇文章中，我们将看到Java中的lambda表达式的异常处理。 Lambda表达式可以引发异常，但应与功能接口的abstract方法的throws子句中指定的异常兼容。

如果lambda表达式主体引发了检查的异常，则函数接口方法的throws子句必须声明相同的异常类型或者其超类型。

Lambda表达式中的已检查异常

在示例抽象方法中，计算功能接口MyFunctionalInterface的方法没有throws子句，但是lambda主体抛出异常。在这种情况下，将生成编译器错误消息"未处理的异常类型异常"。

如果在功能接口方法中指定相同的异常，则可以解决错误，但在调用该方法时确实需要处理该错误。

@FunctionalInterface
interface MyFunctionalInterface{
  int calculate(int i, int j) throws Exception;
}
public class LambdaException {
  public static void main(String[] args) {
    MyFunctionalInterface ref = (x, y) -> {
      int num = x * y;
      throw new Exception();
      //return num;
    };
    try {
      System.out.println("Result is " + ref.calculate(8, 5));
    }catch(Exception e) {
      System.out.println("Exception while calculating " + e.getMessage());
    }
  }
}

Lambda表达式中未经检查的异常

在未检查的异常的情况下，不存在应在功能接口的抽象方法中指定的限制。

在示例示例中，功能接口MyFunctionalInterface的calculate方法没有throws子句，但是lambda主体抛出了运行时异常。

@FunctionalInterface
interface MyFunctionalInterface{
  int calculate(int i, int j);
}
public class LambdaException {
  public static void main(String[] args){
    MyFunctionalInterface ref = (x, y) -> {
      try {
        int num = x/y;
        return num;
      }catch(ArithmeticException e) {
        System.out.println("Exception while calculating- " + e.getMessage());
        throw new RuntimeException(e);
      }
    };

    System.out.println("Result is " + ref.calculate(8, 0));		
  }
}

包装lambda以处理异常

许多人喜欢保持lambda表达式代码简洁明了，没有try catch块。

在这种情况下，我们可以创建包装lambda的包装器类，然后调用它。

@FunctionalInterface
interface MyFunctionalInterface{
  int calculate(int i, int j);
}
public class LambdaException {
  // Lambda wrapper
  static MyFunctionalInterface lambdaWrapper(MyFunctionalInterface ref) {
    return (x, y) -> {
      try {
        ref.calculate(x, y);
      }catch(ArithmeticException e) {
        System.out.println("Exception while calculating- " + e.getMessage());
      }
      return -1;
    };
  }

  public static void main(String[] args){
    // calling lambda wrapp
    MyFunctionalInterface ref = lambdaWrapper((x,y)->x/y);
    System.out.println("Result is " + ref.calculate(8, 0));	
  }
}

输出：

Exception while calculating- / by zero
Result is -1