Optional.ofNullable 详解 | 告别空指针异常，让你的代码更优雅健壮

Optional.ofNullable介绍

Optional.ofNullable 是 Java 中 java.util.Optional 类的一个静态方法，用于返回一个指定值的 Optional 对象。这个方法的主要作用是将一个可能为 null 的值包装到 Optional 容器中。如果该值为 null，则返回一个空的 Optional 对象；否则，返回一个包含该值的 Optional 对象。

该方法的定义如下：

public static <T> Optional<T> ofNullable(T value)

参数：

• value：作为类型 T 的参数，用于创建 Optional 实例。这个参数可以是任意类型的对象，包括基本数据类型的包装类、引用数据类型等，并且可以为 null。

返回值：

• 返回具有指定类型的指定值的 Optional 类的实例。如果指定的值为 null，则此方法返回 Optional 类的空实例。

使用 Optional.ofNullable 方法的主要好处在于，它可以提供一种更优雅的方式来处理可能为 null 的值，避免在代码中直接进行 null 检查，从而简化代码逻辑并提高代码的可读性。

下面是一个简单的示例：

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Integer num = 10;
        Optional<Integer> optional1 = Optional.ofNullable(num);
        System.out.println(optional1.isPresent()); // 输出: true
        System.out.println(optional1.get()); // 输出: 10

        Integer num2 = null;
        Optional<Integer> optional2 = Optional.ofNullable(num2);
        System.out.println(optional2.isPresent()); // 输出: false
        // System.out.println(optional2.get()); // 这行代码会抛出 NoSuchElementException 异常，因为 optional2 是空的
    }
}

在上面的示例中，我们首先创建了一个包含非空值 10 的 Optional 对象 optional1，然后检查它是否包含值（使用 isPresent() 方法），并获取其值（使用 get() 方法）。接着，我们创建了一个空的 Optional 对象 optional2（因为传入的值为 null），并尝试检查它是否包含值以及获取其值。由于 optional2 是空的，尝试调用 get() 方法会抛出 NoSuchElementException 异常。因此，在使用 get() 方法之前，通常建议先使用 isPresent() 方法检查 Optional 对象是否包含值。

总之，Optional.ofNullable 方法提供了一种灵活且安全的方式来处理可能为 null 的值，是 Java 8 引入的一个非常有用的特性。

Optional.ofNullable 后续流处理

Optional.ofNullable 方法后面可以跟随一系列的 Optional 类提供的方法来进行流的处理。

这些方法允许你对可能存在的值进行转换、过滤、映射或其他操作，而无需显式地检查 null。以下是一些常用的 Optional 处理方法及其详细介绍：

1. ifPresent(Consumer<? super T> consumer)

当 Optional 对象包含非空值时，执行给定的 Consumer 接口操作。如果 Optional 为空，则不执行任何操作。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String value = "Hello";
        Optional<String> optional = Optional.ofNullable(value);

        optional.ifPresent(System.out::println); // 如果值存在，则打印它
    }
}

2. map(Function<? super T, ? extends U> mapper)

如果 Optional 对象包含值，则应用提供的 Function 来转换该值，并返回表示结果的新的 Optional 对象。如果原始 Optional 为空，则返回一个空的 Optional。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        Integer number = 10;
        Optional<Integer> optionalNumber = Optional.ofNullable(number);

        Optional<String> optionalString = optionalNumber.map(Object::toString);
        optionalString.ifPresent(System.out::println); // 打印 "10"
    }
}

3. flatMap(Function<? super T, ? extends Optional<U>> mapper)

与 map 类似，但返回的必须是另一个 Optional。这允许你链接多个 Optional 转换操作。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String input = "123";
        Optional<String> optionalInput = Optional.ofNullable(input);

        Optional<Integer> optionalNumber = optionalInput
            .flatMap(s -> Optional.ofNullable(safeParseInt(s))); // 尝试解析字符串为整数

        optionalNumber.ifPresent(System.out::println); // 如果解析成功，则打印整数
    }

    private static Integer safeParseInt(String s) {
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return null;
        }
    }
}

4. orElse(T other)

如果 Optional 对象包含值，则返回该值；否则返回提供的默认值。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String value = null;
        Optional<String> optional = Optional.ofNullable(value);

        String defaultValue = optional.orElse("Default Value");
        System.out.println(defaultValue); // 打印 "Default Value"
    }
}

5. orElseGet(Supplier<? extends T> other)

与 orElse 类似，但只有当 Optional 为空时，才执行 Supplier 并返回其结果。这允许你延迟创建默认值，直到确实需要它。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String value = null;
        Optional<String> optional = Optional.ofNullable(value);

        String defaultValue = optional.orElseGet(() -> createDefaultValue());
        System.out.println(defaultValue); // 打印通过 createDefaultValue() 创建的值
    }

    private static String createDefaultValue() {
        // 假设这里有一些复杂的计算或资源获取操作
        return "Computed Default Value";
    }
}

6. orElseThrow(Supplier<? extends X> exceptionSupplier)

如果 Optional 对象为空，则抛出由提供的 Supplier 创建的异常；否则返回 Optional 中的值。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String value = null;
        Optional<String> optional = Optional.ofNullable(value);

        try {
            String nonNullValue = optional.orElseThrow(() -> new IllegalStateException("Value is not present"));
            System.out.println(nonNullValue);
        } catch (IllegalStateException e) {
            System.out.println(e.getMessage()); // 打印 "Value is not present"
        }
    }
}

7. filter(Predicate<? super T> predicate)

如果 Optional 包含的值满足给定的谓词，则返回该 Optional；否则返回一个空的 Optional。

import java.util.Optional;

public class OptionalExample {
    public static void main(String[] args) {
        String value = "hello";
        Optional<String> optional = Optional.ofNullable(value);

        Optional<String> filteredOptional = optional.filter(s -> s != null && s.length() > 4);
        filteredOptional.ifPresent(System.out::println); // 打印 "hello"，因为它满足条件
    }
}

这些方法允许你以链式调用的方式处理 Optional 对象，从而避免显式的 null 检查和繁琐的条件语句。它们使代码更加简洁、易读，并有助于减少潜在的 NullPointerException。在实际应用中，你可以根据具体需求选择适合的方法来处理 Optional 对象。