正文

Java8中Optional类的使用说明

︶ㄣSDDLL学院 メ
SDDLL学院V管理员 / 阅读
0705
Optional类主要解决的问题是臭名昭著的空指针异常（NullPointerException）,每个Java程序员都非常了解的异常,这篇文章主要给大家介绍了关于Java8中Optional类使用的相关资料,需要的朋友可以参

Optional类主要解决的问题是臭名昭著的空指针异常（NullPointerException）,每个Java程序员都非常了解的异常,这篇文章主要给大家介绍了关于Java8中Optional类使用的相关资料,需要的朋友可以参考下

简介

optional类是java8中引入的针对NPE问题的一种优美处理方式，源码作者也希望以此替代null。

历史

1965年，英国一位名为Tony Hoare的计算机科学家在设计ALGOL W语言时提出了null引用的想法。Hoare选择null引用这种方式，“只是因为这种方法实现起来非常容易”。很多年后，他开始为自己曾经做过这样的决定而后悔不迭，把它称为“我价值百万的重大失误”。我们已经看到它带来的后果——程序员对对象的字段进行检查，判断它的值是否为期望的格式，最终却发现我们查看的并不是一个对象，而是一个空指针，它会立即抛出一个让人厌烦的NullPointerException异常[1]。

null带来的种种问题

  • 错误之源。

NullPointerException是目前Java程序开发中最典型的异常。

  • 代码膨胀。

它让你的代码充斥着深度嵌套的null检查，代码的可读性糟糕透顶。

  • 自身是毫无意义的。

null自身没有任何的语义，尤其是，它代表的是在静态类型语言中以一种错误的方式对缺失变量值的建模。

  • 破坏了Java的哲学。

Java一直试图避免让程序员意识到指针的存在，唯一的例外是：null指针。

  • 在Java的类型系统上开了个口子。

null并不属于任何类型，这意味着它可以被赋值给任意引用类型的变量。这会导致问题，原因是当这个变量被传递到系统中的另一个部分后，你将无法获知这个null变量最初的赋值到底是什么类型。

方案

汲取Haskell和Scala的灵感，Java 8中引入了一个新的类java.util.Optional<T>。这是一个封装Optional值的类。举例来说，使用新的类意味着，如果你知道一个人可能有学校也可能没有，那么Student类内部的school变量就不应该声明为Schoold，遭遇某学生没有学校时把null引用赋值给它，而是应该像本篇那样直接将其声明为Optional<School>类型。

场景引入

首先我们引入一个常见的两个场景

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * >1 引入，常规判断一个学生的学校是不是公立学校，判断是否成年
 */
public static boolean checkIsPublicV1(Student student) {
    if (student != null) {
        School school = student.getSchool();
        if (school != null) {
            return school.isPublicFlag();
        }
    }
    throw new RuntimeException("参数异常");
}
 
public static String getAdultV1(Student student) {
    if (student != null) {
        int age = student.getAge();
        if (age > 18) {
            return student.getName();
        }
    }
    return "无";
}

上述方式是我们常见的判读流程，optional就是针对每次空判断导致的代码欣赏性问题进行了一套解决方案

方法说明

Java8中Optional类的使用说明

构造函数

  • Optional(T var1)

源码

?
1
2
3
4
5
6
7
8
9
private final T value;
 
private Optional() {
    this.value = null;
}
 
private Optional(T var1) {
    this.value = Objects.requireNonNull(var1);
}

从源码可知，optional的构造器私有，不能直接创建，只能通过类中的其他静态方法创建，optional构造器支持一个泛型入参，且改参数不能为空

创建Optional对象

  • 声明一个空的Optional: Optional<T> empty()
  • 依据一个非空值创建Optional: Optional<T> of(T var0)
  • 可接受null的Optional: Optional<T> ofNullable(T var0)

源码

empty()源码

?
1
2
3
4
5
6
7
8
9
10
private static final Optional<?> EMPTY = new Optional();
 
private Optional() {
    this.value = null;
}
 
public static <T> Optional<T> empty() {
    Optional var0 = EMPTY;
    return var0;
}

从源码可知，optional类中维护了一个null值的对象，使用empty静态方法即可返回该空值对象

of(T var0)源码

?
1
2
3
public static <T> Optional<T> of(T var0) {
    return new Optional(var0);
}

返回常见的有参构造对象，注意由于构造器要求入参不能为空，因此of方法的入参为空的话，依然会报NPE异常

ofNullable(T var0)源码

?
1
2
3
public static <T> Optional<T> ofNullable(T var0) {
    return var0 == null ? empty() : of(var0);
}

这个方法是对of方法的补强，当ofNullable方法的入参不为空是正常返回构造对象，当入参为空时，返回一个空值的optional对象，而不会抛出异常。

ofNullable方法大部分场景优于of的使用。

null引用和Optional.empty()有什么本质的区别吗？从语义上，你可以把它们当作一回事儿，但是实际中它们之间的差别非常大：如果你尝试解引用一个null，一定会触发NullPointerException，不过使用Optional.empty()就完全没事儿，它是Op-tional类的一个有效对象，多种场景都能调用，非常有用。

举例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static void testOptionalBuild() {
    // 1. 无法直接new 'Optional()' has private access in 'java.util.Optional'
    // Optional<School> school = new Optional<>();
 
    // 2. of构建非空和空对象(NullPointerException)
    /*Optional<String> o1 = Optional.of("test");
    System.out.println(o1);
    Optional<Object> o2 = Optional.of(null);
    System.out.println(o2);*/
 
    // 3. ofNullable构建非空和空对象(Optional.empty)
    /*Optional<String> o3 = Optional.ofNullable("test");
    System.out.println(o3);
    Optional<Object> o4 = Optional.ofNullable(null);
    System.out.println(o4);*/
}

使用map从Optional对象中提取和转换值

  • Optional<U> map(Function<? super T, ? extends U> var1)

源码

?
1
2
3
4
public <U> Optional<U> map(Function<? super T, ? extends U> var1) {
    Objects.requireNonNull(var1);
    return !this.isPresent() ? empty() : ofNullable(var1.apply(this.value));
}

当optional包裹的值为空时直接放回空对象，否则执行入参中的Function.apply方法

使用flatMap链接Optional对象

  • Optional<U> flatMap(Function<? super T, Optional<U>> var1)

源码

?
1
2
3
4
public <U> Optional<U> flatMap(Function<? super T, Optional<U>> var1) {
    Objects.requireNonNull(var1);
    return !this.isPresent() ? empty() : (Optional)Objects.requireNonNull(var1.apply(this.value));
}

与map几乎一致。注意的是，入参的Function.apply方法中，返回类型为optional类型

举例

?
1
2
3
4
5
6
7
8
9
10
11
public static void testOptionalMap() {
    Student student1 = getDefaultStudent();
    Student student2 = getBackStudent();
    // map
    String school1 = Optional.ofNullable(student1).map(i -> i.getName()).orElse("无名");
    String school2 = Optional.ofNullable(student2).map(i -> i.getName()).orElse("无名");
    System.out.println("school1: " + school1 + "| school2: " + school2);
    // flapMap 链式
    String school3 = Optional.ofNullable(getOptionalStudent()).flatMap(i -> getOptionalStudent()).flatMap(i->i.getSchool()).map(i->i.getSchoolName()).orElse("没上大学");
    System.out.println("school3: " + school3);
}

默认行为及解引用Optional对象1

  • T orElse(T var1)
  • T orElseGet(Supplier<? extends T> var1)
  • T orElseThrow(Supplier<? extends X> var1)

注：这三个方法方法不是静态方法，因此需要通过实例对象调用，一般跟在方法ofNullable后用于处理空值或返回值

源码

orElse源码

?
1
2
3
public T orElse(T var1) {
    return this.value != null ? this.value : var1;
}

当optional中的包裹值不为空时返回包裹的值，若为空则返回orElse中的入参值

orElseGet源码

?
1
2
3
4
5
6
7
8
9
10
public T orElseGet(Supplier<? extends T> var1) {
    return this.value != null ? this.value : var1.get();
}
public T get() {
    if (this.value == null) {
        throw new NoSuchElementException("No value present");
    } else {
        return this.value;
    }
}

与上个方法类似，当optional中的包裹值不为空时返回包裹的值，若为空执行orElseGet中的Supplier方法

orElseThrow源码

?
1
2
3
4
5
6
7
public <X extends Throwable> T orElseThrow(Supplier<? extends X> var1) throws X {
    if (this.value != null) {
        return this.value;
    } else {
        throw (Throwable)var1.get();
    }
}

类似的，当optional中的包裹值不为空时返回包裹的值，若为空抛出orElseThrow中的Supplier.get的异常方法

举例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void testOptionalOrElse() {
    // orElse
    Student stu = getDefaultStudent();
    Student backStudent = getBackStudent();
    Student realStu1 = Optional.ofNullable(stu).orElse(backStudent);
    System.out.println(realStu1);
 
    // orElseGet
    Student realStu2 = Optional.ofNullable(stu).orElseGet(()-> getBackStudent());
    System.out.println(realStu2);
 
    // orElseGet
    Student realStu3 = Optional.ofNullable(stu).orElseThrow(()-> new RuntimeException("学生不存在"));
    System.out.println(realStu3);
}

默认行为及解引用Optional对象2

  • boolean isPresent()
  • void ifPresent(Consumer<? super T> var1)

源码

?
1
2
3
4
isPresent()源码
public boolean isPresent() {
    return this.value != null;
}

用户判断optional包裹的值是否为空，返回布尔值

ifPresent(Consumer var1)源码

?
1
2
3
4
5
public void ifPresent(Consumer<? super T> var1) {
    if (this.value != null) {
        var1.accept(this.value);
    }
}

用户处理optional包裹的值不为空时，继续处理入参中Consumer.accept的方法。类似于 if(var!=null) {do sth}

举例

?
1
2
3
4
5
6
7
8
9
10
11
public static void testOptionalIfPresent() {
    // isPresent()
    Student student1 = getDefaultStudent();
    Student student2 = getBackStudent();
    boolean b1 = Optional.ofNullable(student1).isPresent();
    boolean b2 = Optional.ofNullable(student2).isPresent();
    System.out.println("b1: " + b1 + "| b2: " + b2);
 
    // isPresent(Consumer)
    Optional.ofNullable(student2).ifPresent(i-> acceptStudent(i, LocalDate.now()));
}

使用filter剔除特定的值

  • Optional filter(Predicate<? super T> var1)

源码

?
1
2
3
4
5
6
7
8
public Optional<T> filter(Predicate<? super T> var1) {
    Objects.requireNonNull(var1);
    if (!this.isPresent()) {
        return this;
    } else {
        return var1.test(this.value) ? this : empty();
    }
}

用于对optional对象的过滤，当optional包裹的值不为空时返回该值，否则执行filter入参的Predicate.test方法

举例

?
1
2
3
4
5
6
7
8
9
10
public static void testOptionalFilter() {
    Student student1 = getDefaultStudent();
    Student student2 = getBackStudent();
    System.out.println(student1);
    System.out.println(student2);
    Student student3 = Optional.ofNullable(student1).filter(i -> i.getAge() > 18).orElse(getBackStudent());
    Student student4 = Optional.ofNullable(student2).filter(i -> i.getAge() > 18).orElse(getBackStudent());
    System.out.println(student3);
    System.out.println(student4);
}

实战

关于optional类的说明大致已经讲完，再回到开始的时候，提到的场景引入，结合optional进行改造

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 实战1
 * 针对原来的checkIsPublicV1进行改造
 */
public static boolean checkIsPublicV2(Student student) {
    return Optional.ofNullable(student).map(i -> i.getSchool()).map(i -> i.isPublicFlag()).orElseThrow(() -> new RuntimeException("参数异常"));
}
 
/**
 * 实战1
 * 针对原来的getAdultV1进行改造
 */
public static String getAdultV2(Student student) {
    return Optional.ofNullable(student).filter(i->i.getAge()>18).map(i->i.getName()).orElseGet(()->getDefaultStudent().getName());
}

附：

补充代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public static void main(String[] args) {
    //逐个放开
    // 引入
//        System.out.println(checkIsPublicV1(stu2));
//        System.out.println(getAdultV1(stu2));
    // optional方法
//        testOptionalBuild();
//        testOptionalOrElse();
//        testOptionalIfPresent();
//        testOptionalMap();
//        testOptionalFilter();
    // 实战
//        System.out.println(getAdultV2(stu3));
//        System.out.println(checkIsPublicV2(stu3));
}
 
/**========模型数据=======**/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
static class Student {
    private String name;
    private int age;
    private School school;
}
 
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
static class School {
    private String schoolName;
    private boolean publicFlag;
}
 
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
static class StudentOpt {
    private String name;
    private int age;
    private Optional<School> school;
}
 
public static Student getDefaultStudent() {
    return null;
}
 
public static Student getBackStudent() {
    return Student.builder().name("小红").age(19).build();
}
 
public static Optional<StudentOpt> getOptionalStudent() {
    return Optional.ofNullable(StudentOpt.builder().name("小莫").age(18)
            .school(Optional.ofNullable(School.builder().schoolName("蓝鲸大学").publicFlag(true).build())).build());
}
 
public static void acceptStudent(Student stu, LocalDate date) {
    System.out.println("日期: " + date + " 新增一位学生: " + stu.getName());
}

[1] 参考自java8实战

详细源码，请参考：github.com/chetwhy/clo…

总结

到此这篇关于Java8中Optional类使用的文章就介绍到这了,更多相关Java8 Optional类使用内容请搜索米米素材网以前的文章或继续浏览下面的相关文章希望大家以后多多支持米米素材网！

原文链接：https://juejin.cn/post/7025925484462473246