#Optional 使用最佳实践

// of()：创建非空 Optional，传入 null 抛 NPE
Optional<String> opt1 = Optional.of("hello");

// ofNullable()：可能为空时使用
Optional<String> opt2 = Optional.ofNullable(maybeNull);

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

Optional<String> opt = Optional.ofNullable(getName());

// 判断是否有值
opt.isPresent(); // boolean

// 取值
opt.get(); // 值不存在时抛 NoSuchElementException

// 取值或默认值
opt.orElse("default"); // 值不存在返回 "default"

// 取值或自定义默认值
opt.orElseGet(() -> "computed default"); // 延迟计算

// 取值或抛异常
opt.orElseThrow(() -> new RuntimeException("Not found"));

// ifPresent：有值时执行
opt.ifPresent(name -> System.out.println(name));

// map：转换值
opt.map(String::toUpperCase);

// flatMap：处理嵌套 Optional
opt.flatMap(s -> findByName(s));

// ❌ 错误：Optional 作为字段
class User {
    private Optional<String> name; // 不推荐

    public Optional<String> getName() {
        return name;
    }
}

// 问题：
// 1. Optional 不能序列化！
// 2. 数据库 ORM 映射困难
// 3. 增加了不必要的复杂性

// ✅ 正确：用 null 表示缺失值
class User {
    private String name; // null 表示未设置

    public String getName() {
        return name; // 返回 null，让调用方决定如何处理
    }
}

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

// ❌ orElse()：无论是否有值，都会执行
String s1 = opt.orElse(getDefault()); // 调用了 getDefault()！

// ✅ orElseGet()：有值时不执行
String s2 = opt.orElseGet(() -> getDefault()); // 不调用

// ✅ 正确用法
String defaultName = "default";
String s3 = opt.orElse(defaultName); // 常量用 orElse
String s4 = opt.orElseGet(() -> computeDefault()); // 计算值用 orElseGet

// ❌ 错误
Optional<String> opt = Optional.of(null); // 抛 NullPointerException！

// ✅ 正确
Optional<String> opt = Optional.ofNullable(null); // 返回 Optional.empty()

// ❌ 传统写法：多层嵌套
User user = getUser();
if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        String city = address.getCity();
        if (city != null) {
            return city;
        }
    }
}
return "Unknown";

// ✅ Optional 链式写法
return Optional.ofNullable(getUser())
    .map(User::getAddress)
    .map(Address::getCity)
    .orElse("Unknown");

// ❌ 错误：直接 get() 可能抛异常
String name = list.stream()
    .filter(u -> "Alice".equals(u.getName()))
    .findFirst()
    .get(); // 如果不存在，抛 NoSuchElementException

// ✅ 正确：用 orElse 或 orElseThrow
String name = list.stream()
    .filter(u -> "Alice".equals(u.getName()))
    .findFirst()
    .orElse("Unknown"); // 不存在返回 "Unknown"

// 只在年龄大于等于 18 时才返回名字
Optional<String> name = users.stream()
    .filter(u -> u.getAge() >= 18)
    .map(User::getName)
    .findFirst();

// 如果没有 18+ 的用户，返回空 Optional

// ✅ 正确：可能返回 null 的方法用 Optional
public Optional<User> findById(long id) {
    return users.stream()
        .filter(u -> u.getId() == id)
        .findFirst();
}

// ❌ 不推荐：Optional 做字段
class User {
    private Optional<String> email; // 不要这样
}

// ✅ 推荐：字段用 null
class User {
    private String email; // null 表示未设置
    public Optional<String> getEmail() {
        return Optional.ofNullable(email);
    }
}

// ❌ 不好：返回 Optional<List>
Optional<List<String>> findTags(long userId);

// ✅ 好：返回空列表
List<String> findTags(long userId) {
    return tags.getOrDefault(userId, Collections.emptyList());
}

// Optional：适合处理单个值
Optional.ofNullable(user)
    .map(User::getName)
    .ifPresent(System.out::println);

// Stream：适合处理集合
users.stream()
    .map(User::getName)
    .forEach(System.out::println);

public final class Optional<T> {
    // 两个子类：
    // 1. Optional.Empty：表示空值
    // 2. Optional.Jdk8OptionalImpl：包装非空值

    private final T value;

    // of() 创建时 value != null
    // empty() 返回空实例
    // ofNullable() 根据 value 是否为 null 决定
}