企业官网建设流程全解析

Optional 是 Java 8 引入的容器类，专门用于解决NullPointerException问题，让代码更加安全、优雅。

📚Optional 核心概念

创建 Optional 对象

// 1. 创建包含非空值的 Optional Optional<String> nonEmpty = Optional.of("Hello"); // 2. 创建可能为空的 Optional Optional<String> nullable = Optional.ofNullable(getStringThatMightBeNull()); // 3. 创建空 Optional Optional<String> empty = Optional.empty();

重要区别

// ❌ 危险：如果 value 为 null 会抛出异常 Optional.of(null); // ✅ 安全：允许 null 值 Optional.ofNullable(null);

🚀Optional 方法应用

1. 判断与获取值

Optional<String> optional = Optional.ofNullable(getData()); // 传统判空方式 if (optional.isPresent()) { String value = optional.get(); System.out.println(value); } // 函数式写法 optional.ifPresent(value -> System.out.println(value));

2. 默认值处理

// 如果值为空，返回默认值 String result1 = optional.orElse("默认值"); // 延迟计算的默认值（只有需要时才计算） String result2 = optional.orElseGet(() -> expensiveOperation()); // 如果为空抛出指定异常 String result3 = optional.orElseThrow(() -> new RuntimeException("值不存在"));

3. 链式操作

if 嵌套改写

// 传统嵌套判空（丑陋的代码） if (user != null) { Address address = user.getAddress(); if (address != null) { String city = address.getCity(); if (city != null) { System.out.println(city.toUpperCase()); } } } // Optional 优雅写法 Optional.ofNullable(user) .map(User::getAddress) .map(Address::getCity) .map(String::toUpperCase) .ifPresent(System.out::println);

4. 过滤操作

Optional<User> userOpt = Optional.ofNullable(user); // 只有年龄大于18的用户才处理 userOpt.filter(u -> u.getAge() > 18) .ifPresent(u -> sendAdultNotification(u));

💡实际应用场景

场景1：方法返回值优化

三目运算用Optional.ofNullable-orElse替换

// 传统方式（容易产生 NPE） public String findUserName(Long id) { User user = userRepository.findById(id); // 三目运算 return user != null ? user.getName() : null; // ❌ 可能返回 null } // Optional 优化版 public Optional<String> findUserName(Long id) { // Optional.ofNullable-orElse return Optional.ofNullable(userRepository.findById(id)) .map(User::getName); // ✅ 明确表示可能为空 } // 使用示例 findUserName(123L).ifPresent(name -> System.out.println("用户名: " + name));

场景2：配置参数处理

public class Configuration { private String host; private Integer port; // 传统方式 public String getHost() { return host != null ? host : "localhost"; } // Optional 优化 public Optional<String> getHost() { return Optional.ofNullable(host); } public String getHostWithDefault() { return getHost().orElse("localhost"); } }

场景3：Stream 结合使用

List<String> names = users.stream() .map(User::getNickname) // 可能返回 null .filter(Objects::nonNull) // 过滤掉 null .collect(Collectors.toList()); // 更优雅的 Optional 方式 List<String> safeNames = users.stream() .map(user -> Optional.ofNullable(user.getNickname())) .filter(Optional::isPresent) .map(Optional::get) .collect(Collectors.toList()); // 或者使用 flatMap List<String> bestNames = users.stream() .map(user -> Optional.ofNullable(user.getNickname())) .flatMap(Optional::stream) // Java 9+ 特性 .collect(Collectors.toList());

⚠️常见误区与最佳实践

误区1：滥用 Optional.get()

Optional<String> optional = getOptionalData(); // ❌ 危险：可能抛出 NoSuchElementException String value = optional.get(); // ✅ 安全：先检查再获取 if (optional.isPresent()) { String value = optional.get(); } // ✅ 更安全：使用 orElse 系列方法 String value = optional.orElse("default");

误区2：Optional 作为方法参数

// ❌ 不推荐：使 API 复杂化 public void processData(Optional<String> data) { data.ifPresent(this::doSomething); } // ✅ 推荐：使用重载方法 public void processData(String data) { doSomething(data); } public void processData() { // 处理空值情况 }

误区3：过度使用 Optional

// ❌ 过度使用：简单情况不需要 Optional Optional<String> name = Optional.of("张三"); // ✅ 直接使用即可 String name = "张三";

📊Optional 方法总结

💎总结

Optional 的核心价值：

• ✅明确空值语义- 让 API 更清晰
• ✅减少 NPE- 编译期就能发现潜在问题
• ✅函数式编程- 支持链式操作，代码更优雅
• ✅自文档化- 方法签名明确表示可能返回空值

使用原则：

1. 作为返回值- 明确表示方法可能返回空值
2. 避免作为字段- 会增加复杂度
3. 谨慎作为参数- 通常不需要
4. 不要滥用- 简单情况直接使用 null 检查

========================================================================

集合应用：

Optional 对集合的判空处理

是的，Optional 可以对集合进行判空处理，但需要根据具体场景选择合适的方式。

📚集合判空的几种方式

1. 直接使用 Optional 包装集合

List<String> list = getListFromSomewhere(); // 使用 Optional 包装整个集合 Optional<List<String>> optionalList = Optional.ofNullable(list); // 判断集合是否存在且不为空 if (optionalList.isPresent() && !optionalList.get().isEmpty()) { // 处理非空集合 processList(optionalList.get()); } // 更优雅的写法 optionalList.filter(l -> !l.isEmpty()) .ifPresent(this::processList);

2. 检查集合是否为空的方法

public static <T> boolean isCollectionEmpty(Collection<T> collection) { return Optional.ofNullable(collection) .map(Collection::isEmpty) .orElse(true); // 如果集合为null，则认为空 } // 使用示例 List<String> list = null; System.out.println(isCollectionEmpty(list)); // true list = new ArrayList<>(); System.out.println(isCollectionEmpty(list)); // true list = Arrays.asList("a", "b"); System.out.println(isCollectionEmpty(list)); // false

3. 获取非空集合的便捷方法

public static <T> List<T> getNonNullList(List<T> list) { return Optional.ofNullable(list) .orElse(Collections.emptyList()); } // 使用示例 List<String> result = getNonNullList(possiblyNullList); result.forEach(System.out::println); // 安全，不会NPE

🚀实际应用场景

场景1：API 返回值处理

public List<User> findUsersByCondition(Condition condition) { // 传统方式 List<User> users = userRepository.findByCondition(condition); return users != null ? users : Collections.emptyList(); // Optional 方式 return Optional.ofNullable(userRepository.findByCondition(condition)) .orElse(Collections.emptyList()); }

场景2：Stream 操作前的安全检查

// 传统方式（容易忘记判空） List<String> names = userList.stream() // 如果userList为null会NPE .map(User::getName) .collect(Collectors.toList()); // Optional 安全方式 List<String> safeNames = Optional.ofNullable(userList) .orElse(Collections.emptyList()) .stream() .map(User::getName) .collect(Collectors.toList());

场景3：多层集合判空

public class Company { private List<Department> departments; // getter/setter } public class Department { private List<Employee> employees; // getter/setter } // 传统嵌套判空 if (company != null && company.getDepartments() != null) { for (Department dept : company.getDepartments()) { if (dept.getEmployees() != null) { // 处理员工 } } } // Optional 链式判空 Optional.ofNullable(company) .map(Company::getDepartments) .orElse(Collections.emptyList()) .stream() .map(Department::getEmployees) .filter(Objects::nonNull) .flatMap(List::stream) .forEach(employee -> processEmployee(employee));

⚠️注意事项

1. 不要过度使用 Optional

// ❌ 过度复杂化 Optional.ofNullable(list) .filter(l -> !l.isEmpty()) .ifPresent(l -> l.forEach(...)); // ✅ 简单情况直接判断 if (list != null && !list.isEmpty()) { list.forEach(...); }

2. 性能考虑

// 对于性能敏感的场景，直接判断可能更高效 // Optional 创建对象有开销，在循环中慎用

3. 使用 Collections 工具类

// Java 提供的便捷方法 if (CollectionUtils.isEmpty(list)) { // 很多工具库提供 // 处理空集合 } // 或者使用 Apache Commons 或 Guava if (com.google.common.collect.Iterables.isEmpty(collection)) { // 处理空集合 }

💡最佳实践建议

1. 方法设计

// 返回集合的方法应该避免返回null public List<String> getItems() { // 而不是返回 null return Collections.emptyList(); } // 如果确实可能为null，使用Optional明确表示 public Optional<List<String>> findItems() { // 明确表示可能没有结果 }

2. 统一处理模式

// 创建工具方法统一处理 public class CollectionUtils { public static <T> Stream<T> safeStream(Collection<T> collection) { return Optional.ofNullable(collection) .orElse(Collections.emptyList()) .stream(); } } // 使用示例 CollectionUtils.safeStream(possiblyNullList) .map(...) .filter(...) .collect(...);

💎总结

Optional 对集合判空的优势：

• ✅代码更安全- 避免NullPointerException
• ✅表达更清晰- 明确处理空值情况
• ✅支持链式操作- 与 Stream API 完美结合

适用场景：

• 方法返回值可能为 null 的集合
• 多层对象结构中的集合访问
• Stream 操作前的安全检查

简单规则：

• 简单判空：直接使用if (list != null && !list.isEmpty())
• 复杂链式：使用 Optional 组合操作
• API 设计：优先返回空集合而非 null