Java8之Optional类，巧解NPE

NullPointerException——空指针异常是程序中常见异常之一，也是导致程序运行失败的常见异常。以前，为了防止出现null，我们常在代码中使用if…else…做防御性检查，后来Guava为了解决上述方法造成的代码污染引入了Optional类。

Java8借鉴Guava的Optional也加入了同名的Optional类，Optional类提供了很多实用的方法，借此可以避免显示的空指针判断，从而避免NullPointerException。

常见方法

下面逐一讲解Optional类提供的方法。

of方法

public static <T> Optional<T> of(T value) {
    return new Optional<>(value);
}

Optional中的构造方法都是private的，外部无法使用new方式创建Optional对象，但Optional类提供三个方法用来获取Optional的实例对象。of方法是其中之一，用来创建一个包装对象值非空的Optional实例对象，若包装对象值为空则抛出NullPointerException异常。

// user若为null则会抛出NullPointerException异常
Optional<User> optional_user = Optional.of(user);

ofNullable方法

public static <T> Optional<T> ofNullable(T value) {
    return value == null ? empty() : of(value);
}

获取Optional实例对象的方法之一，返回一个允许包装对象值为空的Optional实例对象。ofNullable与of方法的区别就在是否允许包装对象为空。

// 可以为空，且optional_user1 == optional_user2为true
Optional<User> optional_user1 = Optional.ofNullable(null);
Optional<User> optional_user2 = Optional.ofNullable(null);

empty方法

public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

获取Optional实例对象的方法之一，创建一个包装对象值为空的Optional实例对象。

// 返回包装对象值为空的Optional实例对象
Optional<User> optional_user = Optional.empty();

isPresent方法

public boolean isPresent() {
    return value != null;
}

判断包装对象值是否为空。

// 这里的user不为null
Optional<User> optional_user1 = Optional.ofNullable(user);
Optional<User> optional_user2 = Optional.ofNullable(null);

// 返回true
optional_user1.isPresent();
// 返回false
optional_user2.isPresent();

ifPresent方法

public void ifPresent(Consumer<? super T> consumer) {
    if (value != null)
        consumer.accept(value);
}

判断包装对象值是否为空，如果包装对象的值为空则调用Consumer对象的accept()方法，不为空则不调用。

Optional.ofNullable(user).ifPresent(() -> {
	// 包装对象值为空执行的代码
    ……
});

get方法

public T get() {
    if (value == null) {
        throw new NoSuchElementException("No value present");
    }
    return value;
}

返回包装对象的值，若为空则抛出NoSuchElementException异常。

orElse方法

public T orElse(T other) {
    return value != null ? value : other;
}

若包装对象不是null则返回包装对象的实际值，若为null则返回指定值，即返回传入的参数。

Optional.ofNullable(user).orElse(new User("zhangsan", 20));

orElseGet方法

public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}

作用同orElse方法，只不过orElseGet的入参是Supplier对象，当Optional包装对象为null时返回指定值，返回值由Supplier的get方法产生。

// name是一个String对象
Optional.ofNullable(name).orElseGet(() -> "zhangsan");

orElseThrow方法

public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}

作用同orElseGet类似，当包装对象不为空时返回包装对象的值，为空时返回一个Throwable异常。

filter方法

public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}

过滤Optional的包装对象，当包装对象满足Predicate的条件时返回该Optional实例，否则返回包装对象为null的Optional实例。

// 过滤name为zhangsan的User，当不存在时打印提示信息
Optional.ofNullable(user)
	.filter(u -> u.getName.equals("zhangsan"))
	.ifPresent(() -> System.out.println("There is no zhangsan"));

map方法

public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Optional.ofNullable(mapper.apply(value));
    }
}

map方法对包装对象进行函数运算（即调用Function的apply方法）后返回一个新的Optional实例对象，新Optional实例的包装对象可以时任意类型（不一定与原包装对象的类型保持一致）。

如果包装对象为null则依然返回一个包装对象为null的Optional实例，map可以无限级调用。

// 返回一个Optional<String>
Optional.of(user).map(u -> u.getName());

flatMap方法

public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    Objects.requireNonNull(mapper);
    if (!isPresent())
        return empty();
    else {
        return Objects.requireNonNull(mapper.apply(value));
    }
}

功能同map方法，二者的区别在mapper的apply方法的返回值类型不同，map方法中的mapper返回值可以是任意类型，而flatMap中的mapper的返回值是Optional类型，map方法会自动封装返回一个Optional。

// 返回一个Optional<String>，作用同map的例子
Optional.of(user).flatMap(u -> Optional.of(u.getName()));

解决NPE

在由Optional之前，我们会使用if…else…做防御性检查，以防止出现空指针异常。

public String getUserName(User user) {
  if(user == null) {
    return "unknown";
  }
  return user.getName();
}

有了Optional之后，我们可以这样做了……

public String getUserName(User user) {
  Optional<User> optional_user = Optional.ofNullable(user);
  if(!optional_user.isPresent()) {
    return "unknown";
  }
  return user.getName();
}

啊……这……

显然这两种方法并无本质区别，依然都有防御性检查，依然都不够简洁。只不过第二种方法利用isPresent方法替换了显示的null判断。

正确的姿势。

public String getUserName(User user) {
  // 善用map方法
  return Optional.ofNullable(user)
  				 .map(u -> u.getName())
  				 .orElse("unkonwn");
}

这个例子并不能完全展示Optional的实力，再看下面的示例。

/**
* 获取领导姓名，不使用Optional
* */
public String getBossName(User user) {
  if(user != null) {
    Company company = user.getCompany();
    if(company != null) {
      Boss boss = company.getBoss();
      if(boss != null) {
        return boss.getName();
      }
    }
  }
        
  return "unkonwn";
}

优雅的姿势。

/**
* 获取领导姓名，使用Optional
* */
public String getBossName(User user) {
  return Optional.ofNullable(user)
  				 .map(u -> u.getCompany())
  				 .map(c -> c.getBoss())
  				 .map(b -> b.getName())
  				 .orElse("unkonwn");
}

善用Optional会使我们的代码无比的优雅和简洁。