Java8中Optional类的使用说明

简介

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

历史

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 引入，常规判断一个学生的学校是不是公立学校，判断是否成年

*/

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就是针对每次空判断导致的代码欣赏性问题进行了一套解决方案

方法说明

构造函数

Optional(T var1)

源码

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()源码

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)源码

public static <T> Optional<T> of(T var0) {

return new Optional(var0);

}

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

ofNullable(T var0)源码

public static <T> Optional<T> ofNullable(T var0) {

return var0 == null ? empty() : of(var0);

}

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

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

举例

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 map(Function<? super T, ? extends U> var1)

源码

public  Optional 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 flatMap(Function<? super T, Optional> var1)

源码

public  Optional flatMap(Function<? super T, Optional> var1) {

Objects.requireNonNull(var1);

return !this.isPresent() ? empty() : (Optional)Objects.requireNonNull(var1.apply(this.value));

}

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

举例

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源码

public T orElse(T var1) {

return this.value != null ? this.value : var1;

}

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

orElseGet源码

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源码

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的异常方法

举例

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)

源码

isPresent()源码

public boolean isPresent() {

return this.value != null;

}

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

ifPresent(Consumer var1)源码

public void ifPresent(Consumer<? super T> var1) {

if (this.value != null) {

var1.accept(this.value);

}

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

举例

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)

源码

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方法

举例

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

* 针对原来的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());

}

附：

补充代码

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

本文链接：https://my.lmcjl.com/post/7814.html

展开阅读全文

擅长工具开发、爬虫采集技术、大数据统计处理！
座右铭：皇天不负有心人。

Java8中Optional类的使用说明

目录

简介

历史

null带来的种种问题

方案

场景引入

方法说明

构造函数

创建Optional对象

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

使用flatMap链接Optional对象

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

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

使用filter剔除特定的值

实战

总结

4 评论

留下您的评论. Cancel reply