Java8 特性笔记(六) Optional（含源码分析）

在任何语言开发中我们都会遇到很多bug，然后在众多bug中，空指针又是出现最多的，每个编程语言都有空指针，只不过有些语言对空指针有了系统处理，例如 kotlin会自动检测空指针的存在并在编写代码的时候就报错，java没有这功能，但是在java8之后 有一个类可以为我们解决空指针的问题，它就是Optional

我们看源码里面的一段话，就知道optional想干嘛了

A container object which may or may not contain a non-null value.

可以理解optional是一个容器，它在里面帮我们做了非空判断

接下来我们从源码的角度分析Optional里面的具体功能

1、empty

源码分析：

    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
/**
创建一个空的Optional，也就是里面什么都没有 只是一个空的容器
*/

用法：

Optional<String> emptyOptional = Optional.empty();
        System.out.println(emptyOptional.get());//报错
        System.out.println(emptyOptional.orElse("unkonwn"));//打印unkonwn
//既然是空的里面就没有数据，就不可能拿到数据

2、ofNullable

源码分析：
从源码主注释里面来看，这是在创建一个非空的Optional容器，如果你传入空值，他就会创建一个空的容器，从下面的三目运算符可以看出，如果不是空值，就会调用of方法，of的方法往下翻

    /**
     * Returns an {@code Optional} describing the specified value, if non-null,
     * otherwise returns an empty {@code Optional}.
     *
     * @param <T> the class of the value
     * @param value the possibly-null value to describe
     * @return an {@code Optional} with a present value if the specified value
     * is non-null, otherwise an empty {@code Optional}
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

用法

        Optional<String> optional1 = Optional.ofNullable(null);
        Optional<String> optional2 = Optional.ofNullable("hb");
        System.out.println(optional1); //空值不能调用get 返回Optional.empty
        System.out.println(optional2.get()); //打印hb

3、of

源码分析：
从源码里面看，这里创建的是一个有内容的容器 Optional，注意不要传空值，注释里面说了，传空值会报错的，所以我们再创建的时候还是调用ofNullable这个来创建，你传入空值它就创建空的容器，不是空它就调用of

    /**
     * Returns an {@code Optional} with the specified present non-null value.
     *
     * @param <T> the class of the value
     * @param value the value to be present, which must be non-null
     * @return an {@code Optional} with the value present
     * @throws NullPointerException if value is null
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

4、get

源码分析：
get其实就是返回里面的值，只不过在源码里面帮你做了判断

  /**
     * If a value is present in this {@code Optional}, returns the value,
     * otherwise throws {@code NoSuchElementException}.
     *
     * @return the non-null value held by this {@code Optional}
     * @throws NoSuchElementException if there is no value present
     *
     * @see Optional#isPresent()
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

用法就不多说了，上面有例子，直接调用就行 返回值

5、orElse

源码分析：
从源码里面来看，这个方法传入一个值，如果容器中有值就返回值，如果没有值则返回我们这里传入的值，这里传入的值一般是提示 如 -1

    /**
     * Return the value if present, otherwise return {@code other}.
     *
     * @param other the value to be returned if there is no value present, may
     * be null
     * @return the value, if present, otherwise {@code other}
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

用法：

        Optional<String> optional1 = Optional.ofNullable(null);
        Optional<String> optional2 = Optional.ofNullable("hb");
        System.out.println(optional1.orElse("里面是空的")); //打印 里面是空的
        System.out.println(optional2.get()); //打印hb

6、orElseGet

源码分析：
首先如果值不为空的话和get一样返回值，如果为空就会使用函数式接口，返回函数式接口里面的内容，
如果不懂什么是函数式接口请看我前面的文章，
Supplier 不用传参，返回一个T对象， T表示泛型

    /**
     * Return the value if present, otherwise invoke {@code other} and return
     * the result of that invocation.
     *
     * @param other a {@code Supplier} whose result is returned if no value
     * is present
     * @return the value if present otherwise the result of {@code other.get()}
     * @throws NullPointerException if value is not present and {@code other} is
     * null
     */
    public T orElseGet(Supplier<? extends T> other) {
        return value != null ? value : other.get();
    }

用法：
肯定有人感觉

        Optional<String> optional1 = Optional.ofNullable(null);
        Optional<String> optional2 = Optional.ofNullable("hb");
        System.out.println(optional1.orElse("没有内容")); //打印 里面是空的
        System.out.println(optional2.get());                    //打印hb
        System.out.println(optional1.orElseGet(()->"数据为空")); //打印  hb
        System.out.println(optional2.orElseGet(()->"数据为空")); //打印  数据为空

7、orElseThrow

源码分析
从源码的角度分析我们知道，当Optional中有值的话，就返回该值，没有值的话就抛出一个异常，这个异常是有Supplier函数式接口提供的

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

用法:

Optional<String> stringOptional = Optional.of("hb");
System.out.println(stringOptional.orElseThrow(CustomException::new));

Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.orElseThrow(CustomException::new));

private static class CustomException extends RuntimeException {
   private static final long serialVersionUID = -4399699891687593264L;

   public CustomException() {
       super("exception");
   }

   public CustomException(String message) {
      super(message);
   }
  }

8、filter

源码分析：
在这里我们知道filter这个方法传入一个Predicate的函数式接口，过滤元素，将符合条件的元素重新生成一个Optional对象，否则将会生成一个空的Optional对象
这里的Predicate函数式接口我在前面的文章有详细的介绍

 /**
     * If a value is present, and the value matches the given predicate,
     * return an {@code Optional} describing the value, otherwise return an
     * empty {@code Optional}.
     *
     * @param predicate a predicate to apply to the value, if present
     * @return an {@code Optional} describing the value of this {@code Optional}
     * if a value is present and the value matches the given predicate,
     * otherwise an empty {@code Optional}
     * @throws NullPointerException if the predicate is null
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent())
            return this;
        else
            return predicate.test(value) ? this : empty();
    }

用法:

        Optional<String> optionalList  = Optional.ofNullable("xioaming");
        System.out.println(optionalList.filter(it->it.length()>5).get()); //打印小明
        System.out.println(optionalList.filter(it->it.length()>10).get()); //异常

9 map

源码分析
map这个方法是利用Function进行操作，当其中包含元素，不为空，将元素输入Function函数式接口中，输入一个元素形成另一个并返回，返回类型可以不是Optional类型，源码里可以看到并没有做封装，如果Optional元素为空就会调用empty创建一个空的Optional

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

用法:

Optional<String> stringOptional = Optional.of("xiaoming");
System.out.println(stringOptional.map(e -> e.toUpperCase()).orElse("fail"));
//这里是将字符串全部转换成大写，如果不存在则会调用后面的orElse

10、flagMap

源码分析：
从flagMap的源码里面看到，我们再调用flatMap的时候 返回的类型必须是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));
        }
    }

用法:

Optional<String> stringOptional = Optional.of("xiaoming");
System.out.println(stringOptional.flatMap(e -> Optional.of("haha")).orElse("失败"));
//打印出来的是 haha

11、ifPresent

源码分析
这个方法可能是我们以后用的比较多的方法，它在源码里面的解释知道，它表示在Optional里面的值不为空的情况下使用Consumer函数式接口去消费，也就是我们自己想做什么事，如果为空就什么也不做，肯定不会报错，很好的避免了空指针

    /**
     * If a value is present, invoke the specified consumer with the value,
     * otherwise do nothing.
     *
     * @param consumer block to be executed if a value is present
     * @throws NullPointerException if value is present and {@code consumer} is
     * null
     */
    public void ifPresent(Consumer<? super T> consumer) {
        if (value != null)
            consumer.accept(value);
    }