JAVA 8 Optional类介绍及其源码

什么是Optional对象

Java 8中所谓的Optional对象，即一个容器对象，该对象可以包含一个null或非null值。如果该值不为null，则调用isPresent()方法将返回true，且调用get()方法会返回该值。

另外，该对象还有其它方法：

如可以使用orElse()方法给Optional对象设定默认值（当值为null时，会使用默认值）；

使用ifPresent()方法来执行一段代码（当值不为null时，执行代码段）。

Optional主要被用于Java 8的Stream中，简单举个例子：

package optional;

import java.util.Optional;
import java.util.stream.Stream;

public class Snippet
{
    public static void main(String[] args)
    {
        Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

        Optional<String> startswl = names.filter(name -> name.startsWith("L")).findFirst();

        //判断是否不为null
        if(startswl.isPresent()){
            System.out.println(startswl.get());
        }

        //if值为null：打印“null”；if值不为null：打印原值
        System.out.println(startswl.orElse("null"));

        //if值不为null，执行Lambda表达式
        startswl.ifPresent(name -> {
            String s = name.toUpperCase();
            System.out.println(s);
        });
    }
}

使用Optional对象的好处

减少NullPointerException异常

写出更加优雅的代码

源码及示例

Optional类的属性和方法如下：

aaarticlea/png;base64,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" alt="" />

我们一个个看，先看两个成员属性；

成员属性

如下，一个是EMPTY常量，即存放空值的Optional对象，另一个是value，即被存放的值，可为null或非null值；

    /**
     * Common instance for {@code empty()}.
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * If non-null, the value; if null, indicates no value is present
     */
    private final T value;

构造方法

两个构造方法，注意都是私有的

1、创建一个包含空值的Optional对象；

2、创建一个非空值的Optional对象；

    private Optional() {
        this.value = null;
    }

    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

empty()方法

这个方法很简单，作用是返回一个Optional实例，里面存放的value是null，源码如下：

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

of(T value)方法

很简单，就是返回一个包含非空值的Optional对象

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

ofNullable(T value)方法

很简单，返回一个可以包含空值的Optional对象

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

get()方法

得到Optional对象里的值，如果值为null，则抛出NoSuchElementException异常

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

isPresent()方法

很简单，判断值是否不为null

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

ifPresent(Consumer<? super T> consumer)方法

当值不为null时，执行consumer

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

举个例子，ifPresent方法执行Lambda表达式，将值转换为大写并打印：

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcDef");

        //值不为null，执行Lambda表达式，
        test.ifPresent(name -> {
            String s = name.toUpperCase();
            System.out.println(s);
        });
        //打印ABCDEF
    }
}

filter(Predicate<? super T> predicate)方法

看方法名就知道，该方法是过滤方法，过滤符合条件的Optional对象，这里的条件用Lambda表达式来定义，

如果入参predicate对象为null将抛NullPointerException异常，

如果Optional对象的值为null，将直接返回该Optional对象，

如果Optional对象的值符合限定条件（Lambda表达式来定义），返回该值，否则返回空的Optional对象

源码如下：

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

使用示例：

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcD");

        //过滤值的长度小于3的Optional对象
        Optional<String> less3 = test.filter((value) -> value.length() < 3);
        //打印结果
        System.out.println(less3.orElse("不符合条件，不打印值！"));
    }
}

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

前面的filter方法主要用于过滤，一般不会修改Optional里面的值，map方法则一般用于修改该值，并返回修改后的Optional对象

如果入参mapper对象为null将抛NullPointerException异常，

如果Optional对象的值为null，将直接返回该Optional对象，

最后，执行传入的lambda表达式，并返回经lambda表达式操作后的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));
        }
    }

使用示例：

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcD");

        //将值修改为大写
        Optional<String> less3 = test.map((value) -> value.toUpperCase());
        //打印结果 ABCD
        System.out.println(less3.orElse("值为null，不打印！"));
    }
}

flatMap(Function<? super T, Optional<U>> mapper)方法

flatMap方法与map方法基本一致，唯一的区别是，

如果使用flatMap方法，需要自己在Lambda表达式里将返回值转换成Optional对象，

而使用map方法则不需要这个步骤，因为map方法的源码里已经调用了Optional.ofNullable方法；

源码：

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

使用示例：

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable("abcD");

        //使用flatMap，将值修改为大写
        Optional<String> less3 = test.flatMap((value) -> Optional.ofNullable(value.toUpperCase()));
        //使用map，将值修改为大写
        //Optional<String> less3 = test.map((value) -> value.toUpperCase());

        //打印结果 ABCD
        System.out.println(less3.orElse("值为null，不打印！"));
    }
}

orElse(T other)方法

很简单，当值为null时返回传入的值，否则返回原值；

源码：

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

orElseGet(Supplier<? extends T> other)方法

功能与orElse(T other)类似，不过该方法可选值的获取不是通过参数直接获取，而是通过调用传入的Lambda表达式获取

源码：

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

使用示例：

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable(null);

        System.out.println(test.orElseGet(() -> "hello"));
        //将打印hello
    }
}

orElseThrow(Supplier<? extends X> exceptionSupplier)方法

当遇到值为null时，根据传入的Lambda表达式跑出指定异常

源码

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

使用示例：

package optional;

import java.util.Optional;

public class Snippet
{
    public static void main(String[] args)
    {
        Optional<String> test = Optional.ofNullable(null);

        //这里的Lambda表达式为构造方法引用
        System.out.println(test.orElseThrow(NullPointerException::new));
        //将打印hello
    }
}

参考资料

jdk1.8.0_31源码

https://blog.idrsolutions.com/2015/04/java-8-optional-class-explained-in-5-minutes/

https://www.voxxed.com/blog/2015/05/why-even-use-java-8-optional/

http://unmi.cc/proper-ways-of-using-java8-optional/