自定义异常处理函数和lamda表达式

原创已于 2024-11-07 09:59:46 修改 · 668 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#开发语言 #java #spring boot #后端

于 2024-11-07 09:35:45 首次发布

因为Java是一个面向对象编程的语言，在使用自定义异常类和lamda表达式的时候会引入函数式编程的思想，这与面向对象的思想有些许不同。因此，此文章在一定程度上算是如何将面向对象转换成函数式编程的过程。

在面向对象编程中，我们会思考调用某个类或者是某个实例对象的方法，传入参数，进行逻辑处理，有返回值的话接收返回值（有return关键字提示并显示返回值类型）。

如果 Lambda 表达式包含多行语句，就需要用 大括号 {} 将它们包裹起来，并在需要返回值时显式地使用 return 语句。

语法规则：

单行语句：可以省略 {}，并且如果有返回值，可以直接返回。
多行语句：需要使用 {} 包裹，并在需要返回值的地方使用 return。

示例

1. 单行语句的 Lambda 表达式

java

复制代码

Function<Integer, Integer> square = x -> x * x; System.out.println(square.apply(5)); // 输出 25

单行表达式时，可以省略 {} 和 return，结果会自动作为返回值。

2. 多行语句的 Lambda 表达式

当 Lambda 表达式包含多行语句时，就需要用 {} 包裹整个代码块，并显式地使用 return（如果有返回值）。

java

复制代码

Function<Integer, Integer> multiplyAndAdd = x -> { int result = x * x; result += 10; return result; // 需要 return }; System.out.println(multiplyAndAdd.apply(5)); // 输出 35

在这个例子中：

多行代码使用了 {} 包裹。
使用了 return 明确地返回 result 的值。

3. 无返回值的多行 Lambda 表达式

对于没有返回值的多行 Lambda 表达式，仍然需要用 {} 包裹代码块，但不需要 return。

java

复制代码

Consumer<String> greet = name -> { System.out.println("Hello, " + name + "!"); System.out.println("Welcome!"); }; greet.accept("Alice"); // 输出： // Hello, Alice! // Welcome!

总结

单行语句：可以省略 {} 和 return。
多行语句：需要 {} 包裹；如果有返回值，则需要显式地使用 return。

注意：函数式接口的实现是一个方法，方法，方法。

接下来引出了自定义异常处理函数。

我们在运行程序时可能会遇到异常，这是我们可以创建一个异常处理的函数，及trycatch块来处理异常。

下面我们将自定义异常处理函数与lambda表达式结合：

在 Java 8 中，可以通过 Lambda 表达式在集合处理或流操作中实现自定义异常处理。这通常涉及定义一个“包装器”方法来捕获和处理 Lambda 表达式中可能抛出的异常。

示例：包装 Lambda 表达式中的异常

java

import java.util.Arrays; import java.util.List; import java.util.function.Consumer; public class LambdaExceptionHandling { public static void main(String[] args) { List<String> values = Arrays.asList("10", "20", "ABC", "30"); // 使用包装器来处理 Lambda 表达式中的异常 values.forEach(wrapper(value -> System.out.println(Integer.parseInt(value)))); } // 包装 Lambda 表达式，使其可以处理异常

public static <T> Consumer<T> wrapper(Consumer<T> consumer) {

return t -> { try { consumer.accept(t); }

catch (Exception e)

{ System.out.println("An error occurred: " + e.getMessage()); }

};

}

在这个例子中，wrapper 方法是一个自定义异常处理函数，它包装了 Lambda 表达式的操作，使其可以捕获并处理 forEach 方法中的异常。
如果 Integer.parseInt 遇到无法解析的字符串（如 "ABC"），它会抛出异常并被捕获。

常见的函数式接口

Java 8 提供了许多函数式接口，你可以根据需求选择合适的接口来使用 Lambda 表达式返回值：

Function<T, R>：接受一个类型为 T 的输入并返回一个类型为 R 的结果。
Predicate<T>：接受一个类型为 T 的输入并返回一个布尔值。
Supplier<T>：没有输入参数，返回一个类型为 T 的结果。
Consumer<T>：接受一个类型为 T 的输入并执行某些操作（没有返回值）。

在 Java 中的链式处理（例如流式操作）通常使用函数式接口作为参数。这是因为链式处理需要灵活地接受不同的行为，例如过滤、映射、收集等操作，而函数式接口允许传入的行为是动态的、可定制的。这种设计模式使代码更简洁，并鼓励使用 Lambda 表达式或方法引用来实现流操作中的各种逻辑。

常见的函数式接口

在 Java 的 Stream API 中，以下是一些用于链式处理的常见函数式接口：

Predicate<T>：用于条件判断。返回布尔值，通常用于 filter 操作。
java

复制代码

Stream.of(1, 2, 3, 4, 5) .filter(n -> n % 2 == 0) // 使用 Predicate<T> .forEach(System.out::println); // 输出 2 和 4
Function<T, R>：用于数据转换。接收一个参数并返回一个结果，通常用于 map 操作。
java

复制代码

Stream.of("1", "2", "3") .map(Integer::parseInt) // 使用 Function<T, R> .forEach(System.out::println); // 输出 1、2、3
Consumer<T>：用于处理每个元素。接收一个参数，无返回值，通常用于 forEach 操作。
java

复制代码

Stream.of("A", "B", "C") .forEach(System.out::println); // 使用 Consumer<T>
Supplier<T>：提供一个值。通常用于需要生成对象的场景，如 Optional 或工厂模式。
java

复制代码

Supplier<Double> randomValue = Math::random; // 使用 Supplier<T> System.out.println(randomValue.get()); // 输出随机数
UnaryOperator<T> 和 BinaryOperator<T>：用于接收和返回相同类型的参数。前者处理一个输入值，后者处理两个输入值。通常用于映射或归约操作。
java

复制代码

Stream.of(1, 2, 3, 4) .map(n -> n * 2) // 使用 UnaryOperator<T> .forEach(System.out::println); // 输出 2、4、6、8

链式处理中的函数式接口

链式处理（尤其是 Stream API）大量依赖这些函数式接口，以实现动态行为配置。Lambda 表达式或方法引用常用于这些接口，使得操作更加简洁和可读。例如：

java

复制代码

Stream.of("apple", "banana", "cherry") .filter(s -> s.startsWith("a")) // Predicate<T>：条件过滤 .map(String::toUpperCase) // Function<T, R>：转换为大写 .forEach(System.out::println); // Consumer<T>：输出

以上代码中的 filter、map 和 forEach 方法分别使用了 Predicate、Function 和 Consumer，这些都是函数式接口，用于支持链式操作。