为什么引入Optional类?

身为一名Java程序员,大家可能都有这样的经历:调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。我们首先要判断这个返回值是否为null,只有在非空的前提下才能将其作为其他方法的参数。之前,Google Guava项目曾提出用Optional类来包装对象从而解决NullPointerException。受此影响,JDK8的类中也引入了Optional类,在新版的SpringData Jpa和Spring Redis Data中都已实现了对该方法的支持。Optional是可以包含或不包含非null值的容器对象,如果存在值,则isPresent()将返回true,而get()将返回该值。

如何使用Optional类?

Optional类方法汇总如下:

API 说明
of 把指定的值封装为Optional对象,如果指定的值为null,则抛出NullPointerException
ofNullable 把指定的值封装为Optional对象,如果指定的值为null,则创建一个空的Optional对象
get 如果创建的Optional中有值存在,则返回此值,否则抛出NoSuchElementException
isPresent 如果创建的Optional中的值存在,返回true,否则返回false
ifPresent 如果创建的Optional中的值存在,则执行该方法的调用,否则什么也不做
orElse 如果创建的Optional中有值存在,则返回此值,否则返回一个默认值
orElseGet 如果创建的Optional中有值存在,则返回此值,否则返回一个由Supplier接口生成的值
empty 创建一个空的Optional对象
orElseThrow 如果创建的Optional中有值存在,则返回此值,否则抛出一个由指定的Supplier接口生成的异常
filter 如果创建的Optional中的值满足filter中的条件,则返回包含该值的Optional对象,否则返回一个空的Optional对象
map 如果创建的Optional中的值存在,对该值执行提供的Function函数调用
flagMap 如果创建的Optional中的值存在,就对该值执行提供的Function函数调用,返回一个Optional类型的值,否则就返回一个空的Optional对象

创建Optional实例

  1. 使用empty()

    重申一下,这个类型的对象可能包含值,也可能为空。你可以使用同名方法创建一个空的 Optional。

    @Test(expected = NoSuchElementException.class)
    public void createOptional_empty() {
    Optional<User> emptyOpt = Optional.empty();
    emptyOpt.get();
    }

    毫不奇怪,尝试访问 emptyOpt 变量的值会导致 NoSuchElementException

  2. 使用of()

    在使用of()方法创建包含值得Optional实例,值得注意的是如果你把 null 值作为参数传递进去,of() 方法会抛出 NullPointerException

    @Test(expected = NullPointerException.class)
    public void createOptional_of() {
    Optional<User> opt = Optional.of(user);
    }

    我们并没有完全摆脱 NullPointerException。因此,你应该明确对象不为 null 的时候使用 of()

  3. 使用ofNullable()

    如果对象即可能是 null 也可能是非 null,那么就应该使用 ofNullable() 方法:

    Optional<User> opt = Optional.ofNullable(user);

使用get()访问Optional对象包装的值

Optional 实例中取回实际值对象的方法是使用 get() 方法:

@Test
public void getOptionalValue_ofNullable() {
String name = "Johnson";
Optional<String> opt = Optional.ofNullable(name);
assertEquals("Johnson", opt.get());
}

不过,这个方法会在值为 null 的时候抛出异常。要避免异常,可以使用isPresent()验证是否有值:

@Test
public void getOptionalValue_isPresent() {
User user = new User("johnson", "123");
Optional<User> opt = Optional.ofNullable(user);
assertTrue(opt.isPresent());
assertEquals(user.getName(), opt.get().getName());
}

检查是否有值的另一个选择是 ifPresent() 方法。该方法除了执行检查,还接受一个Consumer(消费者) 参数,如果对象不是空的,就对执行传入的 Lambda 表达式:

opt.ifPresent( u -> assertEquals(user.getName(), u.getName()));

这个例子中,只有 user 用户不为 null 的时候才会执行断言。

Optional包装对象为空情况返回默认值

Optional 类提供了 API 用以返回对象值,或者在对象为空的时候返回默认值。

  1. 使用orElse()

    可以使用orElse()方法,它的工作方式非常直接,如果有值则返回该值,否则返回传递给它的参数值:

    @Test
    public void whenEmptyValue_thenReturnDefault() {
    User user = null;
    User user2 = new User("johnson", "1234");
    User result = Optional.ofNullable(user).orElse(user2);
    assertEquals(user2.getName(), result.getName());
    }

    这里 user 对象是空的,所以返回了作为默认值的 user2

    如果对象的初始值不是 null,那么默认值会被忽略:

    @Test
    public void whenValueNotNull_thenIgnoreDefault() {
    User user = new User("johnson","1234");
    User user2 = new User("johnson", "1234");
    User result = Optional.ofNullable(user).orElse(user2);
    assertEquals("johnson", result.getName());
    }
  2. 使用orElseGet()

    可以使用orElseGet() 方法,这个方法会在有值的时候返回值,如果没有值,它会执行作为参数传入的 Supplier(供应者) 函数式接口,并将返回其执行结果:

    User result = Optional.ofNullable(user).orElseGet( () -> user2);

orElse()orElseGet()方法的不同之处**

我们先来看看对象为空时两者的行为:

@Test
public void givenEmptyValue_whenCompare_thenOk() {
User user = null
logger.debug("Using orElse");
User result = Optional.ofNullable(user).orElse(createNewUser());
logger.debug("Using orElseGet");
User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
} private User createNewUser() {
logger.debug("Creating New User");
return new User("johnson", "1234");
}

上面的代码中,两种方法都调用了 createNewUser() 方法,这个方法会记录一个消息并返回 User 对象。

代码输出如下:

Using orElse
Creating New User
Using orElseGet
Creating New User

由此可见,当对象为空而返回默认对象时,行为并无差异。

我们接下来看一个类似的示例,但这里 Optional 不为空:

@Test
public void givenPresentValue_whenCompare_thenOk() {
User user = new User("johnson", "1234");
logger.info("Using orElse");
User result = Optional.ofNullable(user).orElse(createNewUser());
logger.info("Using orElseGet");
User result2 = Optional.ofNullable(user).orElseGet(() -> createNewUser());
}

这次的输出:

Using orElse
Creating New User
Using orElseGet

这个示例中,两个 Optional 对象都包含非空值,两个方法都会返回对应的非空值。不过,orElse() 方法仍然创建了 User 对象。与之相反,orElseGet()方法不创建 User 对象。

在执行较密集的调用时,比如调用 Web 服务或数据查询,这个差异会对性能产生重大影响

Optional包装对象为空情况返回异常

除了 orElse()orElseGet() 方法,Optional 还定义了 orElseThrow() API —— 它会在对象为空的时候抛出异常,而不是返回备选的值:

@Test(expected = IllegalArgumentException.class)
public void whenThrowException_thenOk() {
User result = Optional.ofNullable(user)
.orElseThrow( () -> new IllegalArgumentException());
}

这里,如果 user 值为 null,会抛出 IllegalArgumentException

这个方法让我们有更丰富的语义,可以决定抛出什么样的异常,而不总是抛出 NullPointerException

现在我们已经很好地理解了如何使用 Optional,我们来看看其它可以对 Optional 值进行转换和过滤的方法。

map()和flatMap()转换Optional包装的值

有很多种方法可以转换 Optional 的值。我们从 map()flatMap() 方法开始。

  1. 使用map()

    先来看一个使用 map() 的例子:

    @Test
    public void whenMap_thenOk() {
    User user = new User("johnson", "1234");
    String email = Optional.ofNullable(user)
    .map(u -> u.getEmail()).orElse("johnson");
    assertEquals(email, user.getName());
    }

    map()对值应用(调用)作为参数的函数,然后将返回的值包装在 Optional中。这就使对返回值进行链试调用的操作成为可能 —— 这里的下一环就是 orElse()

  2. 使用flatMap()

    相比这下,flatMap() 也需要函数作为参数,并对值调用这个函数,然后直接返回结果。

    下面的操作中,我们给 User 类添加了一个方法,用来返回 Optional

    public class User {
    private String position; public Optional<String> getPosition() {
    return Optional.ofNullable(position);
    }
    }

    既然 getter 方法返回 String 值的 Optional,你可以在对 User 的 Optional 对象调用 flatMap() 时,用它作为参数。其返回的值是解除包装的 String 值:

    @Test
    public void whenFlatMap_thenOk() {
    User user = new User("anna@gmail.com", "1234");
    user.setPosition("Developer");
    String position = Optional.ofNullable(user)
    .flatMap(u -> u.getPosition()).orElse("default"); assertEquals(position, user.getPosition().get());
    }

filter()过滤值

除了转换值之外,Optional 类也提供了按条件“过滤”值的方法。

filter()接受一个Predicate参数,返回测试结果为 true 的值。如果测试结果为 false,会返回一个空的 Optional

来看一个根据基本的名称验证来决定接受或拒绝 User(用户) 的示例:

@Test
public void whenFilter_thenOk() {
User user = new User("johnson", "1234");
Optional<User> result = Optional.ofNullable(user)
.filter(u -> u.getName() != null && u.getName().contains("@"));
assertTrue(result.isPresent());
}

如果通过过滤器测试,result 对象会包含非空值。

Optional类的链式方法

为了更充分的使用 Optional,你可以链接组合其大部分方法,因为它们都返回相同类似的对象。

我们使用 Optional 重写最早介绍的示例。

首先,重构类,使其 getter 方法返回 Optional 引用:

public class User {
private Address address; public Optional<Address> getAddress() {
return Optional.ofNullable(address);
} // ...
}
public class Address {
private Country country; public Optional<Country> getCountry() {
return Optional.ofNullable(country);
} // ...
}

现在可以删除 null 检查,替换为 Optional 的方法:

@Test
public void whenChaining_thenOk() {
User user = new User("anna@gmail.com", "1234"); String result = Optional.ofNullable(user)
.flatMap(u -> u.getAddress())
.flatMap(a -> a.getCountry())
.map(c -> c.getIsocode())
.orElse("default"); assertEquals(result, "default");
}

上面的代码可以通过方法引用进一步缩减:

String result = Optional.ofNullable(user)
.flatMap(User::getAddress)
.flatMap(Address::getCountry)
.map(Country::getIsocode)
.orElse("default");

结果现在的代码看起来比之前采用条件分支的冗长代码简洁多了。

总结

Optional 是 Java 语言的有益补充 —— 它旨在减少代码中的 NullPointerExceptions,虽然还不能完全消除这些异常。它也是精心设计,自然融入 Java 8 函数式支持的功能。总的来说,这个简单而强大的类有助于创建简单、可读性更强、比对应程序错误更少的程序。

Java8新特性探索之Optional类的更多相关文章

  1. Java8新特性之五:Optional

    NullPointerException相信每个JAVA程序员都不陌生,是JAVA应用程序中最常见的异常.之前,Google Guava项目曾提出用Optional类来包装对象从而解决NullPoin ...

  2. Java8新特性探索之新日期时间库

    一.为什么引入新的日期时间库 Java对日期,日历及时间的处理一直以来都饱受诟病,尤其是它决定将java.util.Date定义为可修改的以及将SimpleDateFormat实现成非线程安全的. 关 ...

  3. Java8新特性探索之Stream接口

    一.为什么引入Stream流 流是一系列与特定存储机制无关的元素--实际上,流并没有"存储"之说.使用流,无需迭代集合中的元素,就可以从管道提取和操作元素.这些管道通常被组合在一起 ...

  4. Java8新特性探索之函数式接口

    一.为什么引入函数式接口 作为Java函数式编程爱好者,我们都知道方法引用和 Lambda 表达式都必须被赋值,同时赋值需要类型信息才能使编译器保证类型的正确性. 我们先看一个Lambda代码示例: ...

  5. Java8新特性探索之Lambda表达式

    为什么引入Lambda表达式? Lambda 表达式产生函数,而不是类. 在 JVM(Java Virtual Machine,Java 虚拟机)上,一切都是一个类,因此在幕后执行各种操作使 lamb ...

  6. java8新特性之Optional类

    NullPointException可以说是所有java程序员都遇到过的一个异常,虽然java从设计之初就力图让程序员脱离指针的苦海,但是指针确实是实际存在的,而java设计者也只能是让指针在java ...

  7. Java8新特性之空指针异常的克星Optional类

    Java8新特性系列我们已经介绍了Stream.Lambda表达式.DateTime日期时间处理,最后以"NullPointerException" 的克星Optional类的讲解 ...

  8. Java8 新特性 Optional 类

    Optional 类的简介   Optional类的是来自谷歌Guava的启发,然后就加入到Java8新特性中去了.Optional类主要就是为子决解价值亿万的错误,空指针异常.   Optional ...

  9. 【Java8新特性】不了解Optional类,简历上别说你懂Java8!!

    写在前面 最近,很多读者出去面试都在Java8上栽了跟头,事后自己分析,确实对Java8的新特性一知半解.然而,却在简历显眼的技能部分写着:熟练掌握Java8的各种新特性,能够迅速使用Java8开发高 ...

随机推荐

  1. 目标检测算法(一):R-CNN详解

    参考博文:https://blog.csdn.net/hjimce/article/details/50187029 R-CNN(Regions with CNN features)--2014年提出 ...

  2. 遍历 Dictionary,你会几种方式?

    一:背景 1. 讲故事 昨天在 StackOverflow 上看到一个很有趣的问题,说: 你会几种遍历字典的方式,然后跟帖就是各种奇葩的回答,挺有意思,马上就要国庆了,娱乐娱乐吧,说说这种挺无聊的问题 ...

  3. Java基础——克隆

    1.克隆 假设有一个对象object1,在某处又需要一个跟object1一样的实例object2,这两个对象是绝对独立的,不会因为某一个修改另一个随之改变,这样,我们不能直接将对象objec1t的引用 ...

  4. 对抗生成网络 Generative Adversarial Networks

    1. Basic idea 基本任务:要得到一个generator,能够模拟想要的数据分布.(一个低维向量到一个高维向量的映射) discriminator就像是一个score function. 如 ...

  5. Python练习题 010:分解质因数

    [Python练习题 010]将一个正整数分解质因数.例如:输入90,打印出90=2*3*3*5. -------------------------------------------------- ...

  6. Python实现的数据结构与算法之双端队列详解

    一.概述 双端队列(deque,全名double-ended queue)是一种具有队列和栈性质的线性数据结构.双端队列也拥有两端:队首(front).队尾(rear),但与队列不同的是,插入操作在两 ...

  7. c++中sprintf和sprintf_s的区别

    参考:https://blog.csdn.net/qq_37221466/article/details/81140901 sprintf_s是sprintf的安全版本,指定缓冲区长度来避免sprin ...

  8. matlab中set用法

    来源:https://www.cnblogs.com/sddai/p/5467500.html 1.MATLAB给每种对象的每一个属性规定了一个名字,称为属性名,而属性名的取值成为属性值.例如,Lin ...

  9. 【题解】小M的作物

    题目戳我 \(\text{Solution:}\) 这题要求最大收获,可以转化为所有可能的收益减去最小割. 单个点很好连边 \((S\to pos\to T),\) 问题在于如何处理组合的点. 观察到 ...

  10. VS Code对Golang的基准测试研究

    初心 想要在VS Code比较方便的调试Go代码的性能,了解到基准测试对此很有帮助,但默认VS Code执行 Go 的基准测试默认的benchtime为1秒,但测试性能时需要设置为更多秒 办法 在VS ...