JDK8-Optional

Optional是JDK8中提供用于包含未知对象的工具类，即可以利用Optional包装对象来避免繁琐的空指针检查，以及NullPointException的处理，在Optional中，用value代表所包裹的对象。

三种Optional构造方法

Optional.empty

通过静态方法empty创建一个空值的Optional对象

@Test
public void testEmpty() {
    Optional optional = Optional.empty();
}

Optional.of

通过静态方法of创建一个Optional对象，Optional.of()不允许传空值，空值抛NullPointerException

@Test
public void testOf() {
    Person person = new Person();
    Optional optional = Optional.of(person);
}

Optional.ofNullable

通过静态方法ofNullable创建一个Optional对象，传空值返回的是empty的Optional

@Test
public void testOfNullable() {
    Person person = null;
    Optional optional = Optional.ofNullable(person);
}

常用方法

isPresent

判断当前的value是否为null

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

get

返回创建Optional时所包裹的value，若为包裹的value为null则抛出异常NoSuchElementException

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

ifPresent(Consumer<? super T> consumer)

该方法支持传入一个Consumer对象，当value不为null的时候调用，为null则不做任何操作

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

/**
 * ifPresent(Consumer)的测试，当Optional包裹的value不为null时执行Consumer方法
 */
@Test
public void testIfPresent() {
    Optional<String> optional = Optional.of("zh");
    optional.ifPresent(value -> {
        //当Optional包裹的value不为null，执行以下代码块。
        System.out.println(value);
    });
}

filter(Predicate<? super T> predicate)

filter(Predicate)表示：只有value满足Predicate条件的才返回包裹value的Optional，否则返回empty的Optional。value为空时返回本身(也是empty)

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

@Test
public void testFilter() {
    /**
     * 空值返回本身
     */
    Optional<String> optional = Optional.empty();
    Optional<String> optionalResult= optional.filter(value -> value.startsWith("a"));
    System.out.println(optionalResult);

    /**
     * 包裹value满足Predicate的条件返回本身
     */
    optional = Optional.of("张三");
    optionalResult = optional.filter(value -> value.startsWith("张"));
    System.out.println(optionalResult);

    /**
     * 包裹value不满足Predicate的条件返回empty的Optional
     */
    optional = Optional.of("张三");
    optionalResult = optional.filter(value -> value.startsWith("李"));
    System.out.println(optionalResult);

    /**
     * 可以用多个Predicate来判断value
     */
    optional = Optional.of("张三");
    optionalResult = optional.filter(value -> value.startsWith("张")).filter(value -> value.endsWith("三"));
    System.out.println(optionalResult);
}

Optional.empty
Optional[张三]
Optional.empty
Optional[张三]

map(Function<? super T, ? extends U> mapper)

map(Function)表示：对于非空的value，对value执行Function里的方法，并执行后将返回做为新的包裹value

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));
    }
}

@Test
public void testMap(){
    Optional<String> optional = Optional.of("aa");
    Optional<String> result1= optional.map(value -> value.toUpperCase());
    System.out.println(result1);

    optional = Optional.of("王五");
    Optional<Integer> result2= optional.map(value -> value.toUpperCase()).map(value -> value.length());
    System.out.println(result2);
}

Optional[AA]
Optional[2]

flatMap(Function<? super T, ? extends U> mapper)

与map(Function)类似，就是返回值是包裹value，不是Optional对象。

orElse(T other)

即若value为null，则返回默认值other

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

orElseGet(Supplier<? extends T> other)

提供一个Supplier入参，改Supplier提供一个默认值

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

/**
 * orElseGet(Supplier)表示：当包裹value为空时，返回Supplier的get方法的返回值
 */
@Test
public void testOrElseGet(){
    Optional<String> optional=Optional.ofNullable(null);
    System.out.println(optional.orElseGet(() -> "aaa"));
}

aaa

orElseThrow(Supplier<? extends X> exceptionSupplier)

与orElseGet类似，只是Supplier的返回值是Throwable对象。表示：当包裹value为空时，抛Supplier返回的异常

Optional<String> optional=Optional.ofNullable(null);
optional.orElseThrow(()-> new RuntimeException("参数不能为空"));