Optional 是什么

Optional 是 JAVA8 的一个新特性。Optional 类位于 java.util包下，那也就是说它其实是一个工具类。

我们看看官方是怎么介绍 Optional的。

image

java.util.Optional是一个可以包含或不可以包含非空值的容器对象，也就是说可以保存类型为 T 的值，也可以仅仅保存 null 。如果值存在，则 isPresent()方***返回 true，调用其 get()方***返回该值。

Optional 有什么用

Optional 类的引入主要是为了解决空指针异常(NullPointerException)。在我们平常开发中，我相信各位遇到最多的 Exception 也就是 NullPointerException了。各位可能图简单，可能会编写如下代码：

String cardNo = student.getCard().getCardNo().toUpperCase();

就上述代码出现 NullPointerException异常的情况实在是太多了，如果不想出现NullPointerException异常，那就要显示的进行空判断，如下：

String cardNoUpper = null;
if(student != null){
    Card card = student.getCard();
    if(card != null){
        String cardNo = card.getCardNo();
        if (cardNo != null){
            cardNoUpper = cardNo.toUpperCase();
        }
    }
}

可以看到，只能在每个方法都加入非空检查，这样代码的阅读性和维护性都比较差。为了简化这个过程，我们就可以使用Optional了。Optional提供很多有用的方法，这样我们就可以不用显式的进行空值检测。

创建两个类，先来学习一下 Optional的使用方式和使用方法。

public class Student {

    private String name;
    private Integer age;
    private Double grades;
    // Card
    private Card card;
    //get set toString省略
}

public class Card {

    private String cardNo;
    private String cardName;
}

创建 Optional 实例

创建 Optional 实例的方式有三种，分别是of、empty、ofNullable 三个静态方法。接下来分别介绍一下。

Optional.of(T t) : 创建一个 Optional 实例，t 必须非空； @Test public void test1(){ Optional<Student> student = Optional.of(new Student()); Student student1 = student.get(); System.out.println(student1); } 结果：Student{name='null', age=null, grades=null} 复制代码如果 of 方法的参数为 null，会出现空指针异常。该异常发生在创建 Optional 实例的时候。反例：

@Test
public void test1(){
    Optional<Student> student2 = Optional.of(null);
}

image

Optional.empty() : 创建一个空的 Optional 实例

如果硬是要创建一个 null 的 Optional 实例，可以使用该方法。

@Test
public void test2(){
    Optional<Student> student = Optional.empty();
    Student student1 = student.get();
    System.out.println(student1);
}

image

该NoSuchElementException异常发生在 get() 方法被调用时。

Optional.ofNullable(T t)：t 可以为 null。如果非空，使用传入的值构建 Optional；否则返回空的Optional。

@Test
public void test3(){
    Optional<Student> student = Optional.ofNullable(new Student());
    Student student1 = student.get();
    System.out.println(student1);
}
结果：Student{name='null', age=null, grades=null}

如果ofNullable参数传入 null,结果与 empty() 方法一致。源码如下：

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

学会了创建Optional实例的方法，接下来我们看看其他方法。

判断Optional容器中是否包含对象

boolean isPresent()·: 判断是否包含值，如果值存在则返回 true，否则返回 false。

实例：

@Test
public void test4(){
    Optional<Student> student = Optional.ofNullable(new Student());
    if(student.isPresent()){
        Student student1 = student.get();
        System.out.println(student1);
    }

    Optional<Student> student2 = Optional.ofNullable(null);
    //取反
    if (!student2.isPresent()) {
        System.out.println("该对象为空值");
    }
}
结果：
Student{name='null', age=null, grades=null}
该对象为空值

void ifPresent(Consumer<? super T> consumer) ：与上述方法一字之差。如果有值，就执行 accept.accept；否则什么也不做。

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

实例：

  @Test
public void test5(){
    Optional<Student> student = Optional.ofNullable(new Student("新三", 18, 55.0));
    student.ifPresent((x)-> {
        x.setName("李四");
    });
    System.out.println(student.get());
}
结果：Student{name='李四', age=18, grades=55.0}

获取Optional容器的对象

T get(): 如果调用对象包含值，返回该值，否则抛 NoSuchElementException异常
T orElse(T other) ：如果有值则将其返回，否则返回指定的对象

实例：

@Test
public void test6(){

    Optional<Student> op = Optional.ofNullable(null);
    // op 传入null，使用应返回我们指定的对象
    Student st = op.orElse(new Student("新三", 18, 55.0));
    System.out.println(st);

    //传入Student
    Optional<Student> op2 = Optional.ofNullable(new Student());
    Student st2 = op2.orElse(new Student("新三", 18, 55.0));
    System.out.println(st2);
}

Student{name='新三', age=18, grades=55.0}
Student{name='null', age=null, grades=null}

T orElseGet(Supplier<? extends T> other) ：如果有值则将其返回，否则返回由Supplier函数式接口提供的对象。

@Test
public void test7(){
    Optional<Student> op = Optional.ofNullable(null);
    Student st = op.orElseGet(()->{
        //由于是一个函数式接口，里面可以写逻辑
        Student student = new Student();
        student.setAge(99);
        student.setGrades(888.2);
        student.setName("李四");
        return student;
    });
    System.out.println(st);
}
结果：Student{name='李四', age=99, grades=888.2}k6a8

T orElseThrow(Supplier<? extends X> exceptionSupplier) ：如果有值则将其返回，否则抛出由Supplier函数式接口提供的异常

@Test
public void test8(){
    Optional<Student> op = Optional.ofNullable(null);
    Student st = op.orElseThrow(() -> new RuntimeException("值不存在"));
    System.out.println(st);
}

image

Optional map(Function<? super T, ? extends U> mapper)：如果有值对其执行mapper.apply，并返回处理后的Optional。否则返回Optional.empty()。源码如下：

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 test9(){
        Optional<Student> op = Optional.ofNullable(new Student("新,三", 18, 55.0));
        Optional<String[]> s1 = op.map(s -> s.getName())
                                  .map(s -> s.split(","));
        System.out.println(Arrays.toString(s1.get()));
    }
结果：[新, 三]

Optional flatMap(Function<? super T, Optional> mapper)：与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));
    }
}

实例：

 @Test
public void test10(){
    Optional<Student> op = Optional.ofNullable(new Student("新,三", 18, 55.0));
    Optional<String[]> s1 = op.flatMap(s -> Optional.ofNullable(s.getName())
                              .flatMap(s2 -> Optional.ofNullable(s2.split(",")))
    );
    System.out.println(Arrays.toString(s1.get()));
}
结果：[新, 三]

Optional<T> filter(Predicate<? super T> predicate)：如果值存在，并且满足断言条件，就返回该值的Optional，否则返回Optional.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 test11(){
    Optional<Student> optional = Optional.of(new Student("新三", 18, 55.0));
    // 不符合断言条件 返回 Optional.empty
    Optional<Student> opt = optional.filter(s -> {
        return "张".equals(s.getName());
    });
    System.out.println(opt.orElse(new Student("李四", 22, 223.0)));
}

结果：Student{name='李四', age=22, grades=223.0}

到此 Optional的提供的方法到此差不多介绍完毕了，接下来就是完善开篇提到的问题了，怎么使用Optional 来优化一下代码呢？

String cardNoUpper = null;
if(student != null){
    Card card = student.getCard();
    if(card != null){
        String cardNo = card.getCardNo();
        if (cardNo != null){
            cardNoUpper = cardNo.toUpperCase();
        }
    }
}

首先重构一下Student 类内的 getCard方法，返回其 Optional 引用。

public class Student {

    private String name;
    private Integer age;
    private Double grades;
    private Card card;
    // 其余省略。。。
    public Optional<Card> getCard() {
        return Optional.ofNullable(card);
    }

    public void setCard(Card card) {
        this.card = card;
    }
}

准备工作已经完成了，就开始编码吧！

public static void main(String[] args) {
    Student student = new Student("新三", 18, 55.0);
    Card cardObj = new Card("ACafgtc", "工商银行");
    student.setCard(cardObj);
    //Optional<Student> o = Optional.ofNullable(null);
    Optional<Student> o = Optional.ofNullable(student);
    String cardNoUpper = o
            .flatMap(s -> s.getCard())   // 获得 Optional<Card>
            .map(card -> card.getCardNo())    // 获得 Card 内的 cardNo
            .map(cardNo -> cardNo.toUpperCase())
            .orElse("默认值");
    System.out.println(cardNoUpper);
}
结果：ACAFGTC

也可以直接将 Student设置为 null，看会不会出现异常。

public static void main(String[] args) {
    Optional<Student> o = Optional.ofNullable(null);
    String cardNoUpper = o
            .flatMap(s -> s.getCard())   // 获得 Optional<Card>
            .map(card -> card.getCardNo())    // 获得 Card 内的 cardNo
            .map(cardNo -> cardNo.toUpperCase())
            .orElse("默认值");
    System.out.println(cardNoUpper);
}
结果：默认值

总结

对于 Optional这个类，有人觉得没必要去学，因为觉得在工作当中不会使用到它。想法其实是不正确的，虽然我们并不会将自己的方法返回值封装为Optional，但是学习Optional还是很有必要的，不说多的，至少要看得懂，会用。因为现在很多类库在使用Optional封装返回值，比如 Spring Data JPA、Stream API等。

如你对本文有疑问或本文有错误之处，欢迎评论留言指出。如觉得本文对你有所帮助，欢迎点赞和关注。

java8—Optional

Optional 是什么

Optional 有什么用

创建 Optional 实例

判断Optional容器中是否包含对象

获取Optional容器的对象

总结