Optional个人愚见

Optional介绍

Optional是Java8引入了一个的新类，它是一个可以保存单个值或根本不保存任何值容器。主要目的是提供一种更优雅的方式来处理 null 值，避免出现NullPointerException

类属性和方法预览

Optional使用

of

该方法会返回一个value类型为T的Optional对象
如果value为null，则会抛出NullPointerException

//源码
public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }
// 使用
Optional<String> strOpt = Optional.of("hello optioanl");

ofNullable

该方法会根据value是否为空返回对应的Optional对象
value == null，返回一个空Optional对象
value ！= null， 返回一个value值为所传参数的Optional对象

// 源代码
public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
}
// 使用
Optional<String> optional = Optional.ofNullable(null);
Optional<String> optional = Optional.ofNullable("123");

get

返回当前Optional对象的value
如果value为null，则抛出NPE

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

isPresent

判断当前Optional对象的value是否为null

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

filter

如果存在一个值，并且该值与给定的断言匹配，则返回描述该值的 Optional，否则返回空的 Optional
Predicate函数是一个返回值为boolean，入参为当前value的判断类型的函数
filter会通过断言函数对当前Optional对象的value进行判断，并根据结果进行过滤
如果断言函数返回值为true，则返回当前Optional对象
断言函数返回值为false， 则返回一个值为null的Optional对象

// 源码
public Optional<T> filter(Predicate<? super T> predicate) {
    Objects.requireNonNull(predicate);
    if (!isPresent())
        return this;
    else
        return predicate.test(value) ? this : empty();
}
//使用
Optional<String> optional = Optional.ofNullable("");
Optional<String> optionalFilter = optional.filter(StringUtils::isNotBlank)
//optionalFilter = Optional.empty
optional = Optional.ofNullable("filter test");
optionalFilter = optional.filter(StringUtils::isNoneBlank)
//optionalFilter = Optional[filter test]

map

如果存在值，则将提供的映射函数应用于该值，如果结果为非 null，则返回描述结果的 Optional。否则返回空的 Optional。
参数mapper是一个返回值为U，参数为当前value的Function函数

// 源码
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
    //如果函数为null，抛出NEP异常
    Objects.requireNonNull(mapper);
    // 如果当前Optional对象值为null，直接返回空Optional对象
    if (!isPresent())
        return empty();
    else {
        // Function函数返回值为null则返回空Optional，
        // 不为null，则返回Optional[value]
        return Optional.ofNullable(mapper.apply(value));
    }
}
// 使用
// 不改变原有value类型
Optional<String> optional = Optional.ofNullable("filter test");
Optional<String> optionalFilter = optional.map(item -> {
    return StringUtils.equals(item, "map test") ? "map test" : null;
});
// optionalFilter = Optional.empty

// 改变类型
Optional<String> optional = Optional.ofNullable("map test");
Optional<Integer> optionalFilter = optional.map(item -> {
    return StringUtils.equals(item, "map test") ? 1 : null;
});
// optionalFilter = Optional[1]

flatMap

通过执行映射函数，返回一个新Optional对象
参数mapper是一个返回值为Optional，参数为当前value的Function函数

//源码
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
    //如果函数为null，抛出NEP异常
    Objects.requireNonNull(mapper);
    // 如果当前Optional对象值为null，直接返回空Optional对象
    if (!isPresent())
        return empty();
    else {
        // Function函数返回值为null则抛出NEP
        // 不为null，则返回函数的返回值
        return Objects.requireNonNull(mapper.apply(value));
    }
}
//使用
Optional<String> optional = Optional.ofNullable("filter test");
Optional<Integer> optionalFilter = optional.flatMap(item -> {
    return StringUtils.equals(item, "map test") ? Optional.of(1) : Optional.empty();
});
// optionalFilter = Optional[1]

map 和 flatMap区别

共同点：参数都是一个Funtion函数
不同点：
map的参数是一个返回值为任意类型的Function函数，map返回值会对Function返回值进行Optional封装，返回一个Optional对象，就算Function函数返回为null，也不会抛出NEP
flatMap的参数是一个返回值为Optional的Function函数，flatMap返回值则是直接返回Function函数的返回值，并不会进行Optional封装，如果Function函数返回为null，则会抛出NEP

orElse

如果不为null，则返回该值，否则返回其他值。

//源码
public T orElse(T other) {
    return value != null ? value : other;
}
// 使用
String string = Optional.ofNullable("filter test").orElse("orElse test");
// string = filter test
String string = Optional.ofNullable(null).orElse("orElse test");
// string = orElse test

orElseGet

如果不为null，则返回该值，否则返回Supplier的执行结果。
Supplier是一个不需要参数，返回值为T的函数

//源码
public T orElseGet(Supplier<? extends T> other) {
    return value != null ? value : other.get();
}
//使用
String string = Optional.ofNullable("filter test")
  .orElseGet(()->{
      return "orElseGet test";
  });
// string = filter test
String string = Optional.ofNullable(null)
  .orElseGet(()->{
      return "orElseGet test";
  });
// string = orElseGet test

orElseThrow

如果value不为null，则返回该value，否则抛出由Supplier函数创建的异常。
该方法只是对Optional对象的value是否为null进行判断，然后决定是否抛出异常
并不是对Optional的链式调用异常的捕获

// 源码
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
    if (value != null) {
        return value;
    } else {
        throw exceptionSupplier.get();
    }
}
//使用
String string = Optional.ofNullable("orElseThrow test")
      .orElseThrow(()->{
          return new RuntimeException("orElseThrow");
      });
// 此时value为orElseThrow test， string = orElseThrow test
String string = Optional.ofNullable(null)
      .orElseThrow(()->{
          return new RuntimeException("orElseThrow");
      });
// 此时value为null，则会抛出异常，异常信息为orElseThrow
//此时如果orElseThrow前边还有其他操作，并且该操作抛出异常，则不会执行orElseThrow方法

String string = Optional.ofNullable("filter test")
      .filter(item->{
          // 此处会抛NEP，下边orElseThrow并不会执行
          Integer.valueOf(null);
          return item.equals("1234");})
      .orElseThrow(()->{
          return new RuntimeException("orElseThrow");
      });
// 此时异常为NEP，并不是orElseThrow