JDK1.8 java.util.Optional为解决空指针(NullPointerException)而生

Optional是一个容器对象,用来解决令所有程序员头疼的空指针问题

1、empty()

该方法返回一个空的Optional对象

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

2、of(T value)

该方法返回一个包含T的Optional对象，该方法明确规定value为non-null，如果value为null，会抛出NullPointerException

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

3、ofNullable(T value)

该方法返回一个包含T的Optional对象，和of方法不同的是，ofNullable可以接受一个null值而不会抛出NullPointerException，如果value为null则返回一个空的Optional对象

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

4、get()

该方法返回当前Optional对象中保存的值，如果这个值存在则返回，如果不存在则抛出NoSuchElementException

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

5、isPresent()

该方法判断当前容器中是否有值，如果有返回true否则返回false

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

6、ifPresent(Consumer<? super T> consumer)

该方法传入一个Consumer(消费者)，当当前容器中存在值时做一些事情，如果不存在值则什么都不做，当consumer为null时会抛出NullPointerException

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

7、filter(Predicate<? super T> preidcate)

该方法接收一个谓语，返回一个Optional对象，如果当前容器中没有值返回当前对象，如果当前容器中有值则语preidcate进行匹配，如果匹配成功返回当前Optional对象，如果匹配失败返回一个空的Optional对象，如果参数preidcate为null则抛出

NullPointerException

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

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

该方法接收一个函数，如果当前容器中有值则用该函数处理该值得到包含新的类型的值的Optional容器（得到的新值可以为空），如果当前容器为空则返回空Optional对象，如果mapper为null会抛出NullPointerException

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

9、flatMap(Function<? super T, Option<U>> mapper)

该方法类似 8-map方法，不同的是，该方法在函数内部已经包装了Optional容器

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

10、orElse( T other)

如果当前容器中的值不为null，返回这个值，如果为null返回T

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

11、orElseGet(Supplier<? extends T> other)

如果当前容器中的值不为null，返回这个值，如果为null则返回结果供应商other提供的值，如果other为null，抛出NullPointerException

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

12、orElseThrow(Supplier<? extends X> exceptionSupplier) thorw X

如果当前容器中的值不为null，返回这个值，如果为null则抛出供应商exceptionSupplier提供的异常，如果exceptionSupplier为null，抛出NullPointerException

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