Java 8 Optional 详细使用教程-优雅解决NPE

目录

• [1. Optional 简介](#1. Optional 简介)
• [2. Optional 基本用法](#2. Optional 基本用法)
• [3. Optional 常用方法详解](#3. Optional 常用方法详解)
• [4. Optional 实战示例](#4. Optional 实战示例)
• [5. Optional vs 传统null检查](#5. Optional vs 传统null检查)
• [6. 最佳实践与注意事项](#6. 最佳实践与注意事项)

1. Optional 简介

1.1 什么是 Optional

Optional 是 Java 8 引入的一个容器类，代表一个值存在或不存在。Optional 的本质目的是为了解决 NullPointerException（NPE）问题，使代码更加优雅和安全。

1.2 为什么使用 Optional

• 更好的空值处理
• 代码更加简洁优雅
• 强制开发者思考空值情况
• 提高代码可读性

2. Optional 基本用法

2.1 创建 Optional 对象

// 创建空的Optional
Optional<String> empty = Optional.empty();

// 创建包含非空值的Optional 
String name = "John";
Optional<String> opt = Optional.of(name);

// 创建可以包含空值的Optional
String nullableName = null;
Optional<String> optNullable = Optional.ofNullable(nullableName);

Optional.of()和Optional.ofNullable()主要区别:

1. Optional.of(value):
   • 要求传入的值不能为 null
   • 如果传入 null，会立即抛出 NullPointerException
   • 适用于你确定值不为 null 的场景
   • 示例：

Optional<String> opt = Optional.of("Hello"); // 正常
Optional<String> opt = Optional.of(null);   // 抛出 NullPointerException

2. Optional.ofNullable(value):
   • 可以接受 null 值
   • 如果传入 null，会创建一个空的 Optional
   • 适用于不确定值是否为 null 的场景
   • 示例：

Optional<String> opt1 = Optional.ofNullable("Hello"); // 包含 "Hello"
Optional<String> opt2 = Optional.ofNullable(null);   // 空的 Optional

使用：

• 当你确定 值不为 null 时，使用 Optional.of()
• 当可能 为 null 时，使用 Optional.ofNullable()

典型应用场景：

// 安全地处理可能为 null 的值
String result = Optional.ofNullable(someObject)
                        .map(obj -> obj.getValue())
                        .orElse("默认值");

ofNullable() 提供了更灵活和安全的空值处理方式。

2.2 判断值是否存在

Optional<String> opt = Optional.of("Hello");

// 检查是否存在值
boolean isPresent = opt.isPresent(); // 返回 true
boolean isEmpty = opt.isEmpty();     // 返回 false (Java 11+)

// 如果存在值则执行代码
opt.ifPresent(name -> System.out.println("Hello, " + name));

3. Optional 常用方法详解

3.1 map 方法

map 方法用于转换 Optional 中的值。

public class User {
    private String name;
    public String getName() { return name; }
}

Optional<User> user = Optional.of(new User("John"));

// 转换值
Optional<String> userName = user.map(User::getName);

3.2 flatMap 方法

flatMap 用于处理返回 Optional 的方法。

public class User {
    private String name;
    public Optional<String> getName() { 
        return Optional.ofNullable(name); 
    }
}

Optional<User> user = Optional.of(new User());

// 使用 flatMap 处理返回 Optional 的方法
Optional<String> userName = user.flatMap(User::getName);

3.3 filter 方法

filter 用于过滤值。

Optional<String> name = Optional.of("John");

// 使用 filter 过滤
Optional<String> longName = name.filter(str -> str.length() > 3);
Optional<String> shortName = name.filter(str -> str.length() < 3); // 将为空

3.4 orElse 相关方法

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

// 提供默认值
String name1 = empty.orElse("default");

// 提供计算的默认值
String name2 = empty.orElseGet(() -> "computed default");

// 抛出异常
String name3 = empty.orElseThrow(() -> new RuntimeException("Name not found"));

// 使用 or 方法提供备选 Optional (Java 9+)
Optional<String> result = empty.or(() -> Optional.of("backup"));

4. Optional 实战示例

4.1 链式调用示例

public class Address {
    private String street;
    public String getStreet() { return street; }
}

public class User {
    private Address address;
    public Address getAddress() { return address; }
}

// 传统的 null 检查
public String getStreetName(User user) {
    if (user == null) {
        return "Unknown";
    }
    Address address = user.getAddress();
    if (address == null) {
        return "Unknown";
    }
    String street = address.getStreet();
    if (street == null) {
        return "Unknown";
    }
    return street;
}

// 使用 Optional 的优雅方式
public String getStreetNameOptional(User user) {
    return Optional.ofNullable(user)
            .map(User::getAddress)
            .map(Address::getStreet)
            .orElse("Unknown");
}

4.2 集合处理示例

public class Order {
    private List<Item> items;
    public List<Item> getItems() { return items; }
}

// 安全地处理集合
public List<Item> getOrderItems(Order order) {
    return Optional.ofNullable(order)
            .map(Order::getItems)
            .orElse(Collections.emptyList());
}

4.3 条件处理示例

public class UserService {
    public Optional<User> findById(String id) {
        // 数据库查询逻辑
        return Optional.empty();
    }

    public void processUser(String userId) {
        findById(userId)
            .filter(user -> user.getAge() > 18)
            .map(User::getEmail)
            .ifPresent(email -> sendNotification(email));
    }
}

5. Optional vs 传统null检查

5.1 优点

1. 更清晰的语义

// 传统方式
public User getUser(String id) {
    User user = findById(id);
    if (user == null) {
        return new User("anonymous");
    }
    return user;
}

// Optional方式
public User getUser(String id) {
    return Optional.ofNullable(findById(id))
            .orElse(new User("anonymous"));
}

2. 强制考虑null情况

// Optional强制你处理空值情况
Optional<User> user = service.findUser(id);
// 编译器会提醒你处理可能的空值

3. 函数式编程风格

Optional<String> name = Optional.of("John")
    .filter(str -> str.length() > 3)
    .map(String::toUpperCase);

5.2 缺点

1. 性能开销

// Optional会创建额外的对象
Optional<User> user = Optional.of(new User()); // 额外创建了Optional对象

2. 不适合用作类的字段

// 不推荐
public class User {
    private Optional<String> name; // 不要这样做
}

// 推荐
public class User {
    private String name;
    public Optional<String> getName() {
        return Optional.ofNullable(name);
    }
}

6. 最佳实践与注意事项

6.1 推荐做法

1. 用作方法返回值

public Optional<User> findUserById(String id) {
    // ...
}

2. 链式调用

Optional.ofNullable(user)
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

3. 集合为空时返回空集合

public List<User> getUsers() {
    return Optional.ofNullable(userList)
            .orElse(Collections.emptyList());
}

6.2 避免的做法

1. 不要使用Optional.get()而不检查

// 错误做法
Optional<User> user = findUser();
User u = user.get(); // 可能抛出NoSuchElementException

// 正确做法
User u = user.orElseThrow(() -> 
    new UserNotFoundException("User not found"));

2. 不要用Optional包装集合

// 不推荐
Optional<List<User>> users;

// 推荐
List<User> users; // 返回空集合而不是null

3. 避免嵌套Optional

// 不推荐
Optional<Optional<String>> name;

// 推荐使用flatMap
Optional<String> name;

6.3 使用场景建议

1. 适合使用Optional的场景：

• 方法可能返回null的情况
• 链式调用中可能出现null的情况
• 需要提供默认值的情况
• 需要对值进行转换和过滤的情况

2. 不适合使用Optional的场景：

• 类的字段
• 方法参数
• 集合类型的包装
• 序列化场景

总结

Optional 是一个强大的工具，用好它可以:

1. 提高代码的可读性和可维护性
2. 减少NPE的发生
3. 强制开发者思考null值情况
4. 支持函数式编程风格

但要注意合理使用，避免过度使用导致代码复杂化或性能问题。在适当的场景下使用Optional，能够显著提升代码质量。