java8 Optional

一、前言

日常开发中，我们经常会遇到空指针异常（NPE）。可以说，NPE是我们最头疼的问题之一了。为了比变空指针，我们一般会加上判空操作。

如下：

class Teacher {
    private Integer id;
    private String name;
}

class Student {
    private Integer id;
    private String name;
    private Teacher teacher;
}

当我们调用

student.getTeacher().getId()

上面这种写法，很容易产生NullPointerException异常的。为了解决这个问题，于是采用下面的写法：

if(student!=null){
    Teacher t = student.getTeacher();
    if(t!=null){
        Integer id = t.getId();
    }
}    

为了简化上面的写法，我们可以利用Java8的新特性 Optional 来尽量简化代码同时高效处理NPE

 

 

二、Optional类使用解析

1、optional介绍

• Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。
• Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
• Optional 类的引入很好的解决空指针异常。

 

2、构建Optional

构建一个Optional对象，有这些方法：

 

 

• Optional(T value)

 

• empty()

• of(T value)

• ofNullable(T value)

 

先说明一下，Optional(T value)，即构造函数，它是private权限的，不能由外部调用的。其余三个函数是public权限，供我们所调用。那么，Optional的本质，就是内部储存了一个真实的值，在构造的时候，就直接判断其值是否为空。好吧，这么说还是比较抽象。直接上Optional(T value)构造函数的源码，如下图所示：

 

 

 

of(T value)的源码如下

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

也就是说of(T value)函数内部调用了构造函数。根据构造函数的源码我们可以得出两个结论:

• 通过of(T value)函数所构造出的Optional对象，当Value值为空时，依然会报NullPointerException。
• 通过of(T value)函数所构造出的Optional对象，当Value值不为空时，能正常构造Optional对象。

除此之外呢，Optional类内部还维护一个value为null的对象，大概就是长下面这样的

public final class Optional<T> {
    //省略....
    private static final Optional<?> EMPTY = new Optional<>();
    private Optional() {
        this.value = null;
    }
    //省略...
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
}

那么，empty（）的作用就是返回EMPTY对象。

好了铺垫了这么多，可以说ofNullable(T value)的作用了，上源码

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

相比较of(T value)的区别就是，当value值为null时，of(T value)会报NullPointerException异常；ofNullable(T value)不会throw Exception，ofNullable(T value)直接返回一个EMPTY对象。

那是不是意味着，我们在项目中只用ofNullable函数而不用of函数呢?不是的，一个东西存在那么自然有存在的价值。当我们在运行过程中，不想隐藏NullPointerException。而是要立即报告，这种情况下就用of函数。

 

3、Optional API 及源码注解

 

 

 

package java.util;

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
一个可能包含也可能不包含非null值的容器对象。 如果存在值，则isPresent()返回true 。 如果不存在任何值，则该对象被视为空，并且isPresent()返回false 。
提供了其他取决于所包含值是否存在的方法，例如orElse() （如果不存在值，则返回默认值）和ifPresent() （如果存在值，则执行操作）。
这是一个基于值的类； 在Optional实例上使用标识敏感的操作（包括引用等于（ == ），标识哈希码或同步）可能会产生不可预测的结果，应避免使用
 */
public final class Optional<T> {
    /**
     * empty()通用实例
     */
    private static final Optional<?> EMPTY = new Optional<>();

    /**
     * 如果不为空，则为该值；否则为false。 如果为null，则表示不存在任何值
     */
    private final T value;

    /**
        构造一个空实例。
        impl注意：
        通常，每个VM仅应存在一个空实例EMPTY 
     */
    private Optional() {
        this.value = null;
    }

    /**
        返回一个空的Optional实例。 此Optional没有值。
        类型参数：<T> –不存在的值的类型
        返回值：一个空的Optional
        api注意：
        尽管这样做可能很诱人，但应通过将==与Optional.empty()返回的实例进行比较来避免测试对象是否为空。 不能保证它是一个单例。 而是使用isPresent() 
     */
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }

    /**
        使用描述的值构造一个实例。
        参数：值–要描述的非null值
        抛出：NullPointerException如果值为null
     */
    private Optional(T value) {
        this.value = Objects.requireNonNull(value);
    }

    /**
        返回一个Optional描述给定的非null值。
        参数：value –要描述的值，必须为非null
        类型参数：<T> –值的类型
        返回值：存在值的Optiona
     */
    public static <T> Optional<T> of(T value) {
        return new Optional<>(value);
    }

    /**
        返回一个描述给定值的Optional ，如果不为null ，则返回一个空的Optional 。
        参数：值–描述的可能为null值
        类型参数：<T> –值的类型
        返回值：一个Optional与如果指定值是非当前值null ，否则一个空Optional
     */
    public static <T> Optional<T> ofNullable(T value) {
        return value == null ? empty() : of(value);
    }

    /**
        如果存在值，则返回该值，否则抛出NoSuchElementException 。
        返回值：此Optional描述的非null值
        抛出：NoSuchElementException如果不存在任何值
        api注意：此方法的首选替代方法是orElseThrow() 。
     */
    public T get() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
        如果存在值，则返回true ，否则返回false 。

        返回值：如果存在值，则为true ，否则为false
     */
    public boolean isPresent() {
        return value != null;
    }

    /**
        如果不存在值，则返回true ，否则返回false 。

        返回值：如果不存在值，则为true ，否则为false
     */
    public boolean isEmpty() {
        return value == null;
    }

    /**
        如果存在值，则使用该值执行给定的操作，否则不执行任何操作。
        参数：动作–要执行的动作（如果存在值）
     */
    public void ifPresent(Consumer<? super T> action) {
        if (value != null) {
            action.accept(value);
        }
    }

    /**
        如果存在值，则使用该值执行给定的操作，否则执行给定的基于空的操作。
        参数：动作–要执行的动作（如果存在值）emptyAction –要执行的基于空的操作（如果不存在任何值）
        抛出：NullPointerException如果存在一个值并且给定的操作为null ，或者不存在任何值并且给定的基于空的操作为null 
         @since 9
     */
    public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
        if (value != null) {
            action.accept(value);
        } else {
            emptyAction.run();
        }
    }

    /**
        如果存在一个值，并且该值与给定的谓词匹配，则返回描述该值的Optional ，否则返回一个空的Optional 。

        参数：谓词–应用于值的谓词（如果存在）
        返回值：一个Optional描述此的值Optional ，如果一个值存在并且该值给定的谓词相匹配，否则一个空Optional
        抛出：NullPointerException如果谓词为null
     */
    public Optional<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);
        if (!isPresent()) {
            return this;
        } else {
            return predicate.test(value) ? this : empty();
        }
    }

    /**
        如果存在值，则返回一个Optional描述（就像by ofNullable ），将给定映射函数应用于该值的结果，否则返回一个空的Optional 。
        如果映射函数返回null结果，则此方法返回空的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 -bearing映射函数应用于该值的结果，否则返回一个空的Optional 。
        此方法类似于map(Function) ，但是映射函数是其结果已经是Optional函数，如果调用该函数，则flatMap不会将其包装在其他Optional 。

        参数：mapper –应用于值的映射函数（如果存在）
        类型参数：<U> –映射函数返回的Optional值的类型
        返回值：施加的结果Optional荷瘤映射函数此的值Optional ，如果一个值存在，否则一个空Optional
        抛出：NullPointerException如果映射函数为null或返回null结果

     */
    public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
        Objects.requireNonNull(mapper);
        if (!isPresent()) {
            return empty();
        } else {
            @SuppressWarnings("unchecked")
            Optional<U> r = (Optional<U>) mapper.apply(value);
            return Objects.requireNonNull(r);
        }
    }

    /**
        如果值存在时，返回一个Optional描述的值，否则将返回一个Optional产生通过供给功能。

        参数：供应商–产生要返回的Optional的供应功能
        返回值：返回一个Optional描述此的值Optional ，如果一个值存在，否则Optional所生产的供应功能。
        抛出：NullPointerException如果提供的函数为null或产生null结果
     * @since 9
     */
    public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
        Objects.requireNonNull(supplier);
        if (isPresent()) {
            return this;
        } else {
            @SuppressWarnings("unchecked")
            Optional<T> r = (Optional<T>) supplier.get();
            return Objects.requireNonNull(r);
        }
    }

    /**
        如果存在值，则返回仅包含该值的顺序Stream ，否则返回空Stream 。

        返回值：作为Stream的可选值
     * @since 9
     */
    public Stream<T> stream() {
        if (!isPresent()) {
            return Stream.empty();
        } else {
            return Stream.of(value);
        }
    }

    /**
        如果存在值，则返回该值，否则返回other 。

        参数：其他–要返回的值（如果不存在任何值）。 可以为null 。
        返回值：值（如果存在），否则other
     */
    public T orElse(T other) {
        return value != null ? value : other;
    }

    /**
        如果存在值，则返回该值，否则返回由供应函数产生的结果。

        参数：供应商–产生要返回的值的供应函数
        返回值：值（如果存在），否则提供功能产生的结果
     */
    public T orElseGet(Supplier<? extends T> supplier) {
        return value != null ? value : supplier.get();
    }

    /**
     * If a value is present, returns the value, otherwise throws
     * {@code NoSuchElementException}.
     *
     * @return the non-{@code null} value described by this {@code Optional}
     * @throws NoSuchElementException if no value is present
     * @since 10
     */
    public T orElseThrow() {
        if (value == null) {
            throw new NoSuchElementException("No value present");
        }
        return value;
    }

    /**
        如果存在值，则返回该值，否则抛出由异常提供函数产生的异常。

        参数：exceptionSupplier –产生要抛出的异常的提供函数
        类型参数：<X> –引发的异常类型
        返回值：值（如果存在）
        抛出：X –如果不存在任何值NullPointerException如果不存在任何值并且异常提供函数为null
        api注意：带有空参数列表的对异常构造函数的方法引用可用作提供者
     */
    public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
        if (value != null) {
            return value;
        } else {
            throw exceptionSupplier.get();
        }
    }
}

 

 

三、测试使用

1、构建

    public void test01() {
        //返回一个描述给定值的Optional ，如果不为null ，则返回一个空的Optional 。
        //参数：值–描述的可能为null值
        //类型参数：<T> –值的类型
        //返回值：一个Optional与如果指定值是非当前值null ，否则一个空Optional
        Optional s1 = Optional.ofNullable(null);

        // 构建一个value不可以为null的optional对象，如果of()的入参为null会报空指针异常；
        Optional<MyUser> s2 = Optional.of(new MyUser("张三", "123456"));

        // 构建一个value可以为null的optional对象；
        Optional<MyUser> s3 = Optional.ofNullable(null);

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);

        /* 输出
         * Optional.empty
         * Optional[TestRegex.MyUser(name=阿辉2, id=123456)]
         * Optional.empty
         **/
    }

 

2、判断类

public void test02(){
        Optional<MyUser> myUser1 = Optional.empty();
        Optional<MyUser> myUser2 = Optional.of(new MyUser("李四", "123456"));

        // filter传入一个lambda，lambda返回值为boolean；true:不做任何改变，false:返回一个空的optional；
        Optional<MyUser> myUser3 = myUser2.filter(user -> "李四".equals(user.getName()));

        // isPresent就是判断value是不是null；我们在调用get之前，一定要先调用isPresent，因为直接如果value是null，直接调用get会报异常；
        if (myUser1.isPresent()) {
            MyUser value = myUser1.get();
            System.out.println("optional value:" + value);
        } else {
            System.out.println("optional value==null");
        }
        // ifPresent传入一段lambda，当value!=null时，执行里面的逻辑；当当value==null时，啥都不干；
        myUser2.ifPresent(value -> System.out.println("optional value:" + value));
        
        System.out.println(myUser3);

        // 输入如下：
        //  optional value==null
        //  optional value:TestOptional.MyUser(name=李四, id=123456)
        //  Optional[TestOptional.MyUser(name=李四, id=123456)]
    }

 

3、获取类

    public void test03(){
        Optional<MyUser> userInfoEmptyOpt = Optional.empty();
        Optional<MyUser> userInfoOpt = Optional.of(new MyUser("张三","123456"));

        // 1、直接获取，注意如果value==null，会报NoSuchElementException异常
        MyUser userInfo1 = userInfoOpt.get();

        // 2、orElse可以传入一个UserInfo类型的对象作为默认值;
        //    当value!=null时，返回value值；当value==null时，返回默认值作为代替；
        MyUser userInfo2 = userInfoEmptyOpt.orElse(new MyUser("张三1","123456"));

        // 3、orElseGet和orElse不同的是orElseGet可以传入一段lambda表达式；
        // 当value!=null时，返回value值；
        // 当value==null时，使用该lambda返回的对象作为默认值；
        MyUser userInfo3 = userInfoEmptyOpt.orElseGet(() -> new MyUser("张三2","123456"));

        // 4、orElseThrow可以传入一段lambda表达式，lambda返回一个Exception；当value!=null时，返回value值；当value==null时，抛出该异常；
        MyUser userInfo4 = userInfoOpt.orElseThrow(NullPointerException::new);

        System.out.println(userInfo1);
        System.out.println(userInfo2);
        System.out.println(userInfo3);
        System.out.println(userInfo4);

        // 输出如下：
        // TestOptional.MyUser(name=张三, id=123456)
        // TestOptional.MyUser(name=张三1, id=123456)
        // TestOptional.MyUser(name=张三2, id=123456)
        // TestOptional.MyUser(name=张三, id=123456)
    }

 

4、转换类

    public void test04(){
        Optional<MyUser> userInfoOpt = Optional.of(new MyUser("张三","123456"));

        // 原来value的类型是UserInfo，经过map转换为Optional<String>
        Optional<String> username = userInfoOpt.map(MyUser::getName);

        // 当map的入参也是一个Optional时，经过map转化后会形成Optional<Optional<String>>这种嵌套结构；但flatMap可以把这种嵌套结构打平；
        Optional<Optional<String>> unFlatMap = userInfoOpt.map(user -> Optional.of(user.getName()));
        Optional<String> flatMap = userInfoOpt.flatMap(user -> Optional.of(user.getName()));

        System.out.println(username);
        System.out.println(unFlatMap);
        System.out.println(flatMap);

        // 输出如下：
        // Optional[张三]
        // Optional[Optional[张三]]
        // Optional[张三]
    }

 

 

四、总结

回到前言的那个问题，我们可以用如下代码替换：

    public String getId(Student student) throws Exception{
        return Optional.ofNullable(student)
                .map(u-> u.getTeacher())
                .map(a->a.getId())
                .orElseThrow(()->new Exception("取值错误"));
    }

其他的例子，不一一列举了。不过采用这种链式编程，虽然代码优雅了。但是，逻辑性没那么明显，可读性有所降低，大家项目中看情况酌情使用。