java8 Optional操作解决NullPointerException

java8 Optional操作

起源：主要解决NullPointerException问题，但不仅限于此

1. 问题

String isocode = user.getAddress().getCountry().getIsocode().toUpperCase();

此时，为了避免触发异常，在访问每一个值之前进行明确的检查

if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Country country = address.getCountry();
        if (country != null) {
            String isocode = country.getIsocode();
            if (isocode != null) {
                isocode = isocode.toUpperCase();
            }
        }
    }
}

显而易见这样冗长且难以维护

2. 创建Optional对象

1.Optional<User> emptyOpt = Optional.empty();
2.Optional<User> opt = Optional.of(user);
3.Optional<User> opt = Optional.ofNullable(user);

明确对象不为 null 时使用of，否则ofNull

3. 从Optional对象中取值

Optional<String> opt = Optional.ofNullable("name");
 opt.get();

4. 非空判断

opt.isPresent();

opt.ifPresent( u -> assertEquals(user.getEmail(), u.getEmail()));

ifPresent除了执行检查，还接受一个Consumer(消费者) 参数，如果对象不是空的，就对执行传入的 Lambda 表达式：例如这里u不为空时会执行断言

5. 为空返回默认值

    User user = null;
    User user2 = new User("anna@gmail.com", "1234");
    User result = Optional.ofNullable(user).orElse(user2);
	//user为空时返回user否则返回user
	User result = Optional.ofNullable(user).orElseGet( () -> user2);
	//orElseGet()会在有值的时候返回值，如果没有值，它会执行作为参数传入的 Supplier(供应者) 函数式接口，并将返回其执行结果

二者区别：对象非空时orElse仍会执行createNewUser方法，调用较密集时会造成较大的性能差异

public void givenEmptyValue_whenCompare_thenOk() {
    User user = null;
    User result = Optional.ofNullable(user).orElse(createNewUser());
    User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
}

private User createNewUser() {
    logger.debug("Creating New User");
    return new User("extra@gmail.com", "1234");
}

6. 转换值

   	User user = new User("anna@gmail.com", "1234");
    String email = Optional.ofNullable(user)
      .map(u -> u.getEmail()).orElse("default@gmail.com");
	//map() 对值应用(调用)作为参数的函数，然后将返回的值包装在 Optional 中
	
	//相比这下，flatMap() 也需要函数作为参数，并对值调用这个函数，然后直接返回结果。
 	String position = Optional.ofNullable(user)
      .flatMap(u -> u.getPosition()).orElse("default");
    //这里要orElse链式处理getPosition()返回的是一个optional对象
	 public Optional<String> getPosition() {
        return Optional.ofNullable(position);
    }

7. 过滤值

   //根据email拒绝user
    User user = new User("anna@gmail.com", "1234");
    Optional<User> result = Optional.ofNullable(user)
      .filter(u -> u.getEmail() != null && u.getEmail().contains("@"));

    assertTrue(result.isPresent());

filter() 接受一个 Predicate 参数，返回测试结果为 true 的值。如果测试结果为 false，会返回一个空的 Optional。

8. Optional 类的链式方法
   为了更充分的使用 Optional，你可以链接组合其大部分方法，因为它们都返回相同类似的对象。我们使用 Optional 重写最早介绍的示例。首先，重构类，使其 getter 方法返回 Optional 引用

public class User {
    private Address address;

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

    // ...
}
public class Address {
    private Country country;

    public Optional<Country> getCountry() {
        return Optional.ofNullable(country);
    }
}

现在可以删除 null 检查，替换为 Optional 的方法

  User user = new User("anna@gmail.com", "1234");

    String result = Optional.ofNullable(user)
      .flatMap(u -> u.getAddress())
      .flatMap(a -> a.getCountry())
      .map(c -> c.getIsocode())
      .orElse("default");

    assertEquals(result, "default");

上面的代码可以通过方法引用进一步缩减

String result = Optional.ofNullable(user)
  .flatMap(User::getAddress)
  .flatMap(Address::getCountry)
  .map(Country::getIsocode)
  .orElse("default");

重要的一点是 Optional 不是 Serializable。因此，它不应该用作类的字段
Java 9 为 Optional 类添加了三个方法：or()、ifPresentOrElse() 和 stream()

Optional 主要用作返回类型。在获取到这个类型的实例后，如果它有值，你可以取得这个值，否则可以进行一些替代行为。

Optional 类有一个非常有用的用例，就是将其与流或其它返回 Optional 的方法结合，以构建流畅的API
示例，使用 Stream 返回 Optional 对象的 findFirst() 方法：

public void whenEmptyStream_thenReturnDefaultOptional() {
    List<User> users = new ArrayList<>();
    User user = users.stream().findFirst().orElse(new User("default", "1234"));

    assertEquals(user.getEmail(), "default");
}