发布于 由admin

Java 21无名模式在switch表达式null处理中NPE？TypePattern与GuardedPattern空安全组合

Java 21 无名模式在 Switch 表达式 Null 处理中的 NPE？Type Pattern 与 Guarded Pattern 空安全组合

大家好，今天我们来深入探讨 Java 21 中无名模式（Unnamed Patterns）在 switch 表达式中处理 null 值时可能出现的空指针异常（NPE），以及如何利用类型模式（Type Patterns）和守卫模式（Guarded Patterns）来构建更健壮、空安全的 switch 表达式。

1. 无名模式的引入与基本概念

Java 21 引入的无名模式，也称为通配符模式，使用下划线 _ 表示。它主要用于 switch 表达式中，当我们只需要匹配某种类型，而不需要绑定匹配到的值到特定变量时，就可以使用无名模式。这在处理多种类型，但对某些类型不需要进一步操作的情况下非常有用，能够简化代码，提高可读性。

例如：

Object obj = "Hello";

String result = switch (obj) {
    case String s -> "String: " + s;
    case Integer i -> "Integer: " + i;
    case _ -> "Other type"; // 无名模式，匹配所有其他类型
};

System.out.println(result); // 输出：String: Hello

在这个例子中，如果 obj 既不是 String 也不是 Integer，则会匹配到无名模式，执行 _ -> "Other type" 分支。

2. NullPointerException 的隐患：无名模式与 Null 值

虽然无名模式简洁方便，但在处理可能为 null 的对象时，如果不小心，很容易触发 NullPointerException。 考虑以下情况：

Object obj = null;

String result = switch (obj) {
    case String s -> "String: " + s;
    case Integer i -> "Integer: " + i;
    case _ -> "Other type"; // 无名模式
};

System.out.println(result); // 抛出 NullPointerException

为什么会抛出 NullPointerException？ 这是因为 switch 表达式在尝试匹配 case 时，会首先进行类型检查。即使使用了无名模式 _，switch 表达式依然会尝试对 null 值进行类型匹配。 在这种情况下，null 值无法匹配任何具体的类型（String 或 Integer），因此最终会落入 case _ 分支。 但是，在进入 case _ 之前，JVM 已经尝试对 null 进行类型匹配，这会导致 NullPointerException。

本质上，switch 表达式的类型匹配机制并没有针对 null 值进行特殊处理。它仍然会尝试将 null 值与 case 中的类型进行比较，从而触发异常。

3. 类型模式（Type Patterns）：显式 Null 处理

解决 NullPointerException 的关键在于显式地处理 null 值。 Java 的类型模式提供了一种优雅的方式来实现这一点。类型模式允许我们在 case 子句中直接进行类型判断，并且可以结合 null 检查：

Object obj = null;

String result = switch (obj) {
    case String s -> "String: " + s;
    case Integer i -> "Integer: " + i;
    case null -> "Null value"; // 显式处理 null 值
    default -> "Other type";  // 相当于无名模式，但更加明确
};

System.out.println(result); // 输出：Null value

在这个例子中，我们添加了一个 case null 子句，专门用于处理 null 值。 这样，当 obj 为 null 时，switch 表达式会直接匹配到 case null 分支，而不会尝试进行其他类型匹配，从而避免了 NullPointerException。

重要区别：

  • case _ (无名模式) 在 switch 表达式尝试匹配所有类型失败后才会执行，但在匹配前会先尝试类型匹配，导致 null 值的异常。
  • case null 显式地处理 null 值，避免了类型匹配的尝试，从而避免了异常。

4. 守卫模式（Guarded Patterns）：更复杂的条件判断

除了类型模式，我们还可以使用守卫模式来添加更复杂的条件判断。 守卫模式使用 when 关键字，允许我们在 case 子句中添加额外的布尔表达式：

Object obj = "  ";

String result = switch (obj) {
    case String s when !s.isBlank() -> "Non-blank String: " + s;
    case String s -> "Blank String";
    case Integer i -> "Integer: " + i;
    case null -> "Null value";
    default -> "Other type";
};

System.out.println(result); // 输出：Blank String

在这个例子中，我们首先判断 obj 是否为 String 类型，如果是，则进一步判断 s.isBlank() 是否为 false。 只有当 obj 是 String 类型，并且 s.isBlank() 为 false 时，才会执行 case String s when !s.isBlank() -> "Non-blank String: " + s 分支。

5. 类型模式与守卫模式的空安全组合

我们可以将类型模式和守卫模式结合起来，构建更强大的空安全 switch 表达式。 例如，我们可以在守卫模式中使用 Objects.nonNull() 来确保在访问对象的属性或方法之前，对象不是 null：

Object obj = null;

String result = switch (obj) {
    case String s when Objects.nonNull(s) && !s.isBlank() -> "Non-blank String: " + s;
    case String s -> "String, but null or blank";
    case Integer i -> "Integer: " + i;
    case null -> "Null value";
    default -> "Other type";
};

System.out.println(result); // 输出：Null value

在这个例子中，case String s when Objects.nonNull(s) && !s.isBlank() -> ... 这条分支只有在 obj 是 String 类型，并且 obj 不为 null 且不是空白字符串时才会执行。 如果 obj 是 String 类型，但是是 null 值，那么会匹配到 case String s -> "String, but null or blank"; 这条分支。

更安全的方式：

虽然上面的代码可以工作，但 case String s -> "String, but null or blank"; 这条分支仍然可能导致 NullPointerException，如果 s 是 null 的话。 更安全的方式是显式地使用 null 检查：

Object obj = null;

String result = switch (obj) {
    case String s when Objects.nonNull(s) && !s.isBlank() -> "Non-blank String: " + s;
    case String s when Objects.isNull(s) -> "String, but null";
    case String s -> "String, but blank"; // s 肯定不是 null，否则会先匹配到 null
    case Integer i -> "Integer: " + i;
    case null -> "Null value";
    default -> "Other type";
};

System.out.println(result); // 输出：Null value

或者使用更简洁的版本：

Object obj = null;

String result = switch (obj) {
    case String s when s != null && !s.isBlank() -> "Non-blank String: " + s;
    case String s when s == null -> "String, but null";
    case String s -> "String, but blank"; // s 肯定不是 null，否则会先匹配到 null
    case Integer i -> "Integer: " + i;
    case null -> "Null value";
    default -> "Other type";
};

System.out.println(result); // 输出：Null value

6. 最佳实践与注意事项

在编写涉及 null 值的 switch 表达式时，请遵循以下最佳实践：

  • 始终显式处理 null 值： 使用 case null 子句来明确处理 null 值。
  • 使用 Objects.nonNull() 或 != null 进行空值检查： 在守卫模式中使用 Objects.nonNull() 或 != null 来确保在访问对象属性或方法之前，对象不是 null。
  • 注意 case 子句的顺序： switch 表达式按照 case 子句的顺序进行匹配。 将更具体的 case 子句放在前面，将更通用的 case 子句放在后面。 例如，case String s when Objects.nonNull(s) 应该放在 case String s 之前。
  • 避免在无名模式中使用可能为 null 的对象： 尽量避免在无名模式中使用可能为 null 的对象，以防止 NullPointerException。

7. 案例分析：更复杂的数据结构

让我们考虑一个更复杂的案例，假设我们有一个 Result 类，它可能包含一个 value 字段，也可能包含一个 error 字段。 value 和 error 字段可能为 null。

class Result<T> {
    private final T value;
    private final String error;

    public Result(T value, String error) {
        this.value = value;
        this.error = error;
    }

    public T getValue() {
        return value;
    }

    public String getError() {
        return error;
    }
}

我们想要编写一个 switch 表达式来处理 Result 对象，根据 value 和 error 字段的值返回不同的消息。

Result<String> result1 = new Result<>("Success", null);
Result<String> result2 = new Result<>(null, "Error");
Result<String> result3 = new Result<>(null, null);
Result<String> result4 = null;

String message1 = switch (result1) {
    case Result<String> r when r != null && r.getValue() != null -> "Value: " + r.getValue();
    case Result<String> r when r != null && r.getError() != null -> "Error: " + r.getError();
    case Result<String> r when r != null -> "Result is valid, but both value and error are null";
    case null -> "Result is null";
};

String message2 = switch (result2) {
    case Result<String> r when r != null && r.getValue() != null -> "Value: " + r.getValue();
    case Result<String> r when r != null && r.getError() != null -> "Error: " + r.getError();
    case Result<String> r when r != null -> "Result is valid, but both value and error are null";
    case null -> "Result is null";
};

String message3 = switch (result3) {
    case Result<String> r when r != null && r.getValue() != null -> "Value: " + r.getValue();
    case Result<String> r when r != null && r.getError() != null -> "Error: " + r.getError();
    case Result<String> r when r != null -> "Result is valid, but both value and error are null";
    case null -> "Result is null";
};

String message4 = switch (result4) {
    case Result<String> r when r != null && r.getValue() != null -> "Value: " + r.getValue();
    case Result<String> r when r != null && r.getError() != null -> "Error: " + r.getError();
    case Result<String> r when r != null -> "Result is valid, but both value and error are null";
    case null -> "Result is null";
};

System.out.println("Message 1: " + message1); // 输出：Message 1: Value: Success
System.out.println("Message 2: " + message2); // 输出：Message 2: Error: Error
System.out.println("Message 3: " + message3); // 输出：Message 3: Result is valid, but both value and error are null
System.out.println("Message 4: " + message4); // 输出：Message 4: Result is null

在这个案例中，我们使用了类型模式和守卫模式来处理 Result 对象，并显式地检查了 result 对象本身以及 value 和 error 字段是否为 null，从而避免了 NullPointerException。

8. 表格总结：Null 处理策略对比

Null 处理方式 优点 缺点 适用场景
无名模式 (case _) 简洁，可以匹配所有未被其他 case 子句匹配到的值。 无法显式处理 null 值，容易导致 NullPointerException。 当确定输入不会为 null，或者在 switch 表达式之前已经处理了 null 值时。
case null 显式处理 null 值，避免 NullPointerException。 需要显式添加 case null 子句。 当输入可能为 null 时，必须使用。
类型模式 + 守卫模式 可以进行更复杂的条件判断，例如使用 Objects.nonNull() 或 != null 进行空值检查。 代码相对复杂。 当需要进行复杂的条件判断，并且输入可能为 null 时。

9. 确保 Null 安全的 Switch 表达式

总而言之，在 Java 21 的 switch 表达式中使用无名模式时，务必小心处理 null 值。 通过结合类型模式和守卫模式，显式地处理 null 值，可以构建更健壮、空安全的 switch 表达式，避免潜在的 NullPointerException。 记住，清晰、明确的代码胜过简洁但可能隐藏风险的代码。

类型模式与守卫模式的组合是关键

确保 switch 表达式的 null 安全，关键在于使用类型模式显式处理 null，并结合守卫模式进行更精细的条件判断。

显式处理 null 避免潜在风险

在处理可能为 null 的对象时，避免依赖隐式的类型匹配，而是通过显式处理 null 来降低 NPE 的风险。

注意 case 顺序，提升代码可读性

case 子句的顺序会影响 switch 表达式的执行结果，将更具体的 case 放在前面，有助于提高代码的可读性和可维护性。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注