用Optional后代码变清爽多了

前言

编程路上风雨兼程，踩过的坑比喝过的奶茶还要多几分回味。今天，咱们深入浅出，探讨一个既平凡又深奥的操作——判空艺术，特别是那经典桥段 != null。在与臭名昭著的 NullPointerException（简称NPE，程序界的“空指针噩梦”）的持久战中，这招几乎是程序员的护身法宝。

想当年，我还是编程界的新兵蛋子，对 null 敏感得像雷达，逢 null 必严谨判空，if (某物 != null)简直是开场白一般的存在。但随着时间的发酵，经验值蹭蹭上涨，我渐渐悟出：这频繁的判空虽是保险，却也像给代码穿上了一层又一层的秋衣，臃肿不说，还常常捂出些难以捉摸的Bug来。

试想，代码里布满了迷宫般的 if-else 判空逻辑，别说一眼找出Bug，就算你瞪大眼睛外加放大镜，也得绕晕在那“是空非空”的哲学迷雾中。更别提，过度判空让程序员们变得草木皆兵，每行代码都藏着一颗“我到底有没有判空？”的忐忑心。这时候，修复Bug就像拆盲盒，刺激中带着一丝无奈：“我当初为啥要判这个空来着？”😢

好在，Java 8 带来了救星——Optional，它简直就是判空界的清流，优雅地解决了我们的问题。使用 Optional，你可以把可能为 null 的对象包裹起来，通过一系列简洁的方法调用来避免直接触碰那令人头疼的 null，从而让代码更加清晰、安全，仿佛给代码做了一场瑜伽，柔韧且有力。

所以，与其在判空的泥潭里越陷越深，不如拥抱 Optional，让我们的代码轻盈起舞，远离 “空指针”的阴霾，迈向更加优雅和健壮的编程新境界。🌟

用 Optional 来拯救你的代码

Java 8 给我们带来了个神器——Optional。
简单来说，它就是个包装类，用来装那些可能为 null 的对象。用了 Optional，你就不用再到处写 != null 来判空了。举个例子，咱们看个传统的写法：

User user = getUserFromSomewhere();
if (user!= null) {
    Address address = user.getAddress();
    if (address!= null) {
        String city = address.getCity();
        if (city!= null) {
            System.out.println(city);
        } else {
            System.out.println("City not found.");
        }
    } else {
        System.out.println("Address not found.");
    }
} else {
    System.out.println("User not found.");
}

再看看用了 Optional 之后的写法：

import java.util.Optional;

Optional<User> optionalUser = Optional.ofNullable(getUserFromSomewhere());
optionalUser.map(User::getAddress)
          .map(Address::getCity)
          .ifPresent(System.out::println);
optionalUser.map(User::getAddress)
          .map(Address::getCity)
          .orElse("City not found.");

这一下是不是清爽了许多？代码不仅短了，逻辑也更明确了。一句话概括：少点啰嗦，多点优雅。

常用API

创建Optional的对下你个有以下三种方式：

Optional.of(value): 创建一个包含非空值的 Optional 对象
如果传递的值为 null，会抛出 NullPointerException

Optional<String> nonNullOptional = Optional.of("Hello, World!");

Optional.ofNullable(value): 创建一个 Optional 对象，如果传递的值为 null，仍然会创建一个空的 Optional 对象

Optional<String> optional = Optional.ofNullable(someNullableValue);

Optional.empty(): 创建一个空的 Optional 对象

Optional<String> emptyOptional = Optional.empty();

常用的操作方法

isPresent(): 判断 Optional 对象是否包含非空值

if (optional.isPresent()) {
    // do something
}

ifPresent(Consumer<? super T> consumer): 如果 Optional 对象包含非空值，则执行传入的操作

optional.ifPresent(value -> System.out.println("value: " + value));

orElse(T other): 如果 Optional 对象包含非空值，则返回该值；否则返回传入的默认值

String result = optional.orElse("默认值");

orElseGet(Supplier<? extends T> other): 类似于 orElse，但是默认值是由传入的 Supplier 提供的

String result = optional.orElseGet(() -> genDefaultValue());

orElseThrow(Supplier<? extends X> exceptionSupplier): 如果 Optional 对象为空，则抛出由传入的 Supplier 提供的异常

String result = optional.orElseThrow(() -> new NoSuchElementException("Value not present"));

Java 9 增强

我们介绍了 Java 8 的特性，Java 9 为 Optional 类添加了三个方法：or()、ifPresentOrElse() 和 stream()。

or() 方法与 orElse() 和 orElseGet() 类似，它们都在对象为空的时候提供了替代情况。or() 的返回值是由 Supplier 参数产生的另一个 Optional 对象。

来个demo

假设我们有一个用户信息系统，其中包含用户的姓名、年龄和地址。我们需要从数据库中获取用户信息，并进行一些处理。

import java.util.Optional;

public class UserInfoSystem {
    public static void main(String[] args) {
        // 从数据库中获取用户信息（模拟）
        User user = getUserFromDatabase();

        // 使用Optional处理用户信息
        Optional<User> optionalUser = Optional.ofNullable(user);

        // 打印用户姓名
        optionalUser.ifPresent(u -> System.out.println("用户姓名: " + u.getName()));

        // 计算用户年龄的平方（如果年龄存在）
        optionalUser.map(User::getAge)
              .map(age -> age * age)
              .ifPresent(squaredAge -> System.out.println("用户年龄的平方: " + squaredAge));

        // 获取用户地址的城市（如果地址存在）
        optionalUser.flatMap(User::getAddress)
              .map(Address::getCity)
              .ifPresent(city -> System.out.println("用户地址的城市: " + city));
    }

    public static User getUserFromDatabase() {
        // 模拟从数据库中获取用户信息，这里返回一个可能为空的用户对象
        return new User("Alice", 25, new Address("New York"));
        // 可以返回 null 来模拟用户不存在的情况
        // return null;
    }

    static class User {
        private String name;
        private int age;
        private Address address;

        public User(String name, int age, Address address) {
            this.name = name;
            this.age = age;
            this.address = address;
        }

        public String getName() {
            return name;
        }

        public int getAge() {
            return age;
        }

        public Optional<Address> getAddress() {
            return Optional.ofNullable(address);
        }
    }

    static class Address {
        private String city;

        public Address(String city) {
            this.city = city;
        }

        public String getCity() {
            return city;
        }
    }
}

在这个例子中，我们使用Optional来包装从数据库中获取的用户对象。这样，我们可以在处理用户信息时，避免空指针异常。

例如，当我们获取用户姓名时，使用ifPresent方法来确保用户存在。当我们计算用户年龄的平方时，使用map方法来转换年龄，并使用ifPresent方法来处理结果。当我们获取用户地址的城市时，使用flatMap方法来处理嵌套的Optional。

通过这种方式，Optional提供了一种更安全、更优雅的方式来处理可能为空的值，使代码更具可读性和健壮性。

总结

Optional 是 Java 语言的有益补充 —— 它旨在减少代码中的 NullPointerException，虽然还不能完全消除这些异常。

它也是精心设计，自然融入 Java 8 函数式支持的功能。

总的来说，这个简单而强大的类有助于创建简单、可读性更强、比对应程序错误更少的程序。

资料

• https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Optional.html
• https://forums.oracle.com/ords/apexds/post/optionals-patterns-and-good-practices-2540