避免 Java 中的 null 检查

1. 概述

在 Java 编程中，null 是一个非常容易引发问题的值。无论是变量、引用还是集合，null 都难以在编译期识别，最终可能在运行时抛出 NullPointerException。

本篇文章将探讨 Java 中为什么需要进行 null 检查，以及有哪些替代方案可以避免在代码中频繁使用 null 检查。

2. 什么是 NullPointerException？

根据 Java 官方文档，当程序试图在需要对象实例的地方使用 null 时，就会抛出 NullPointerException。常见场景包括：

调用 null 对象的实例方法
访问或修改 null 对象的字段
获取 null 对象的数组长度
将 null 当作数组访问其元素
抛出 null 作为 Throwable 对象

举个例子：

public void doSomething() {
    String result = doSomethingElse();
    if (result.equalsIgnoreCase("Success")) 
        // success
    }
}

private String doSomethingElse() {
    return null;
}

上面代码中，我们尝试调用 null 对象的方法，结果就是抛出 NullPointerException。

再来看一个数组访问的例子：

public static void main(String[] args) {
    findMax(null);
}

private static void findMax(int[] arr) {
    int max = arr[0];
    // check other elements in loop
}

这会导致第 6 行抛出 NullPointerException。

因此，访问 null 对象的字段、方法或数组索引都会引发异常。

一个常见的解决办法是添加 null 检查：

public void doSomething() {
    String result = doSomethingElse();
    if (result != null && result.equalsIgnoreCase("Success")) {
        // success
    }
    else
        // failure
}

private String doSomethingElse() {
    return null;
}

但在实际开发中，程序员很难判断哪些对象可能为 null。虽然可以对所有对象都进行 null 检查，但这样会导致冗余代码，降低代码可读性。

接下来我们将介绍几种替代方案，帮助你减少甚至避免 null 检查。

3. 通过 API 合约处理 null

上一节提到，访问 null 对象的字段或方法会抛出异常。为了避免这个问题，通常的做法是添加 null 检查。

但有些 API 可以处理 null 值，比如：

public void print(Object param) {
    System.out.println("Printing " + param);
}

public Object process() throws Exception {
    Object result = doSomething();
    if (result == null) {
        throw new Exception("Processing fail. Got a null response");
    } else {
        return result;
    }
}

print() 方法即使传入 null 也不会抛出异常，只是输出 "null"。process() 方法则永远不会返回 null，而是抛出异常。

所以调用这些 API 的客户端代码就不需要再做 null 检查了。

但前提是这些 API 必须明确在文档中声明其行为。常见的做法是通过 Javadoc 说明。

不过这种方式依赖开发者自觉遵守 API 合约，缺乏强制性。

下一节我们将介绍如何通过静态分析工具和 IDE 来强化 API 合约。

4. 自动化 API 合约检查

4.1 使用静态代码分析工具

静态代码分析工具可以帮助提高代码质量。其中一些工具（如 FindBugs）还支持通过注解来定义 null 合约。

FindBugs 提供了 @Nullable 和 @NonNull 注解，可以标注方法、字段、局部变量或参数，明确该对象是否允许为 null。

示例：

public void accept(@NonNull Object param) {
    System.out.println(param.toString());
}

这里 @NonNull 明确表示参数不能为 null。如果客户端代码没有检查就传入 null，FindBugs 会在编译时给出警告。

4.2 使用 IDE 支持

大多数 Java 开发者都使用 IDE（如 IntelliJ IDEA）。IDE 提供了智能提示、代码分析等功能，也能帮助开发者避免 null 相关问题。

IntelliJ IDEA 提供了自己的 @NonNull 和 @Nullable 注解。要使用这些注解，只需添加如下 Maven 依赖：

<dependency>
    <groupId>org.jetbrains</groupId>
    <artifactId>annotations</artifactId>
    <version>16.0.2</version>
</dependency>

这样 IntelliJ 就会在你遗漏 null 检查时给出警告。

此外，IntelliJ 还支持 @Contract 注解，可以用于定义更复杂的 API 合约。

5. 使用断言

前面我们讨论了如何通过 API 合约减少客户端代码的 null 检查。但在实际项目中，很多接口参数或返回值仍需要检查 null。

此时可以考虑使用 Java 的 assert 语句：

public void accept(Object param){
    assert param != null;
    doSomething(param);
}

第 2 行检查参数是否为 null，如果断言启用，会抛出 AssertionError。

⚠️ 注意：这种方式有两个明显缺点：

JVM 默认不启用断言
断言失败会抛出不可恢复的错误

因此，不推荐使用断言处理运行时的 null 检查。

接下来我们将介绍几种更实用的 null 处理方式。

6. 通过编码规范避免 null 检查

6.1 使用 Preconditions

一个良好的编码习惯是“失败尽早”。如果一个接口有多个参数不能为 null，可以在方法入口处统一检查：

public void goodAccept(String one, String two, String three) {
    if (one == null || two == null || three == null) {
        throw new IllegalArgumentException();
    }

    process(one);
    process(two);
    process(three);
}

相比分散检查，这种方式更清晰，也更容易维护。

你也可以使用 Guava 的 Preconditions 工具类进行参数校验。

6.2 使用基本类型而非包装类

基本类型如 int 不允许为 null，因此应优先使用基本类型而非包装类（如 Integer）：

public static int primitiveSum(int a, int b) {
    return a + b;
}

public static Integer wrapperSum(Integer a, Integer b) {
    return a + b;
}

调用时：

int sum = primitiveSum(null, 2); // 编译报错

而使用包装类时：

assertThrows(NullPointerException.class, () -> wrapperSum(null, 2));

✅ 推荐优先使用基本类型，避免运行时 null 问题。

6.3 返回空集合而非 null

当方法返回集合时，应尽量返回空集合而非 null：

public List<String> names() {
    if (userExists()) {
        return Stream.of(readName()).collect(Collectors.toList());
    } else {
        return Collections.emptyList();
    }
}

这样客户端调用时无需判断 null，直接使用集合方法即可。

7. 使用 Objects 工具类

Java 7 引入了 Objects 工具类，其中包含多个实用方法，可以简化 null 处理。

比如 requireNonNull() 方法可以用于参数校验：

public void accept(Object param) {
    Objects.requireNonNull(param);
    // doSomething()
}

如果传入 null，会抛出 NullPointerException。

此外还有 isNull() 和 nonNull() 方法，可以作为判断条件使用。

8. 使用 Optional

Java 8 引入了 Optional 类，提供了一种更优雅的方式来处理可能为空的对象。

8.1 使用 orElseThrow

public Optional<Object> process(boolean processed) {
    String response = doSomething(processed);
    return Optional.ofNullable(response);
}

private String doSomething(boolean processed) {
    if (processed) {
        return "passed";
    } else {
        return null;
    }
}

通过返回 Optional，调用方可以明确知道结果可能为空，并使用 orElseThrow() 等方法处理：

assertThrows(Exception.class, () -> process(false).orElseThrow(() -> new Exception()));

8.2 Optional 与集合结合使用

处理集合时，Optional 非常有用：

public String findFirst() {
    return getList().stream()
      .findFirst()
      .orElse(DEFAULT_VALUE);
}

如果集合为空，返回默认值。

也可以返回 Optional，让客户端决定如何处理：

public Optional<String> findOptionalFirst() {
    return getList().stream().findFirst();
}

8.3 组合多个 Optional

当多个方法返回 Optional 时，可以通过 flatMap 等方式组合：

public Optional<String> optionalListFirst() {
   return getOptionalList()
      .flatMap(list -> list.stream().findFirst());
}

这样可以避免嵌套的 Optional<Optional<T>>，使代码更清晰。

9. 使用第三方库简化 null 处理

9.1 使用 Lombok 的 @NonNull 注解

Lombok 是一个减少样板代码的库，其 @NonNull 注解可以自动插入 null 检查：

public void accept(@NonNull Object param){
    System.out.println(param);
}

Lombok 编译后会自动生成：

if (param == null) {
    throw new NullPointerException("param");
}

这样可以避免手动添加 null 检查。

Maven 依赖：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.30</version>
</dependency>

9.2 使用 StringUtils 简化字符串判断

处理字符串时，我们常常需要判断是否为 null 或空字符串：

if (null != param && !param.isEmpty())

可以使用 Apache Commons Lang 的 StringUtils.isNotEmpty() 方法简化：

if (StringUtils.isNotEmpty(param))