Java函数式编程之Optional
前提
java.util.Optional是JDK8中引入的类，它是JDK从著名的Java工具包Guava中移植过来。本文编写的时候使用的是JDK11。Optional是一个包含了NULL值或者非NULL值的对象容器，它经常使用做明确代表没有结果（其实明确代表存在结果也能够用Optional表示）的方法返回类型，这样能够避免NULL值带来的可能的异常（通常是NullPointerException）。也就是说，一个方法的返回值类型是Optional，则应该避免返回NULL，而应该让返回值指向一个包含NULL对象的Optional实例。Optional的出现为NULL判断、过滤操做、映射操做等提供了函数式适配入口，它算是Java引入函数式编程的一个重要的里程碑。java
本文新增一个Asciidoc的预览模式，能够体验一下Spring官方文档的感受：git
- Github Page：www.throwable.club/adoc/201908…
- Coding Page：throwable.coding.me/adoc/201908…
Optional各个方法源码分析和使用场景
Optional的源码比较简单，归根于它是一个简单的对象容器。下面会结合源码分析它的全部构造、属性、方法和对应的使用场景。github
Optional属性和构造
Optional的属性和构造以下：编程
public final class Optional<T> {
// 这个是通用的表明NULL值的Optional实例
private static final Optional<?> EMPTY = new Optional<>();
// 泛型类型的对象实例
private final T value;
// 实例化Optional，注意是私有修饰符，value置为NULL
private Optional() {
this.value = null;
}
// 直接返回内部的EMPTY实例
public static<T> Optional<T> empty() {
@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
// 经过value实例化Optional，若是value为NULL则抛出NPE
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}
// 经过value实例化Optional，若是value为NULL则抛出NPE，实际上就是使用Optional(T value)
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
// 若是value为NULL则返回EMPTY实例，不然调用Optional#of(value)
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
// 暂时省略其余代码
}
复制代码
若是明确一个对象实例不为NULL的时候，应该使用Optional#of()，例如：安全
Order o = selectByOrderId(orderId);
assert null != o
Optional op = Optional.of(o);
复制代码
若是没法明确一个对象实例是否为NULL的时候，应该使用Optional#ofNullable()，例如：app
Optional op = Optional.ofNullable(selectByOrderId(orderId));
复制代码
明确表示一个持有NULL值的Optional实例可使用Optional.empty()。函数式编程
get()方法
// 若是value为空，则抛出NPE，不然直接返回value
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
复制代码
get()方法通常是须要明确value不为NULL的时候使用，它作了先验value的存在性。例如：函数
Order o = selectByOrderId(orderId);
assert null != o
Optional op = Optional.of(o);
Order value = op.get();
复制代码
isPresent()方法
// 判断value是否存在，不为NULL则返回true，若是为NULL则返回false
public boolean isPresent() {
return value != null;
}
复制代码
举个例子：工具
Order o = selectByOrderId(orderId);
boolean existed = Optional.ofNullable(o).isPresent();
复制代码
isEmpty()方法
isEmpty()是JDK11引入的方法，是isPresent()的反向判断：源码分析
// 判断value是否存在，为NULL则返回true，为非NULL则返回false
public boolean isEmpty() {
return value == null;
}
复制代码
ifPresent()方法
ifPresent()方法的做用是：若是value不为NULL，则使用value调用消费者函数式接口的消费方法Consumer#accept()：
public void ifPresent(Consumer<? super T> action) {
if (value != null) {
action.accept(value);
}
}
复制代码
例如：
Optional.ofNullable(selectByOrderId(orderId)).ifPresent(o-> LOGGER.info("订单ID:{}",o.getOrderId());
复制代码
ifPresentOrElse()方法
ifPresentOrElse()方法是JDK9新增的方法，它是ifPresent()方法的增强版，若是value不为NULL，则使用value调用消费者函数式接口的消费方法Consumer#accept()，若是value为NULL则执行Runnable#run()：
public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction) {
if (value != null) {
action.accept(value);
} else {
emptyAction.run();
}
}
复制代码
例如：
String orderId = "xxxx";
Optional.ofNullable(selectByOrderId(orderId)).ifPresentOrElse(o-> LOGGER.info("订单ID:{}",o.getOrderId()), ()-> LOGGER.info("订单{}不存在",o.getOrderId()));
复制代码
filter()方法
public Optional<T> filter(Predicate<? super T> predicate) {
// 判断predicate不能为NULL
Objects.requireNonNull(predicate);
// value为NULL，说明是空实例，则直接返回自身
if (!isPresent()) {
return this;
} else {
// value不为NULL，则经过predicate判断，命中返回自身，不命中则返回空实例empty
return predicate.test(value) ? this : empty();
}
}
复制代码
这个方法的功能是简单的过滤功能，容器持有对象value非NULL会作一次判断，决定返回自身实例仍是empty()。例如：
Optional.ofNullable(selectByOrderId(orderId)).filter(o -> o.getStatus() == 1).ifPresent(o-> LOGGER.info("订单{}的状态为1",o.getOrderId));
复制代码
map()方法
map()是简单的值映射操做：
public <U> Optional<U> map(Function<? super T, ? extends U> mapper) {
// 判断mapper不能为NULL
Objects.requireNonNull(mapper);
// value为NULL，说明是空实例，则直接返回empty()
if (!isPresent()) {
return empty();
} else {
// value不为NULL，经过mapper转换类型，从新封装为可空的Optional实例
return Optional.ofNullable(mapper.apply(value));
}
}
复制代码
API注释里面的一个例子：
List<URI> uris = ...;
// 找到URI列表中未处理的URI对应的路径
Optional<Path> p = uris.stream().filter(uri -> !isProcessedYet(uri)).findFirst().map(Paths::get);
复制代码
flatMap()方法
flatMap()方法也是一个映射操做，不过映射的Optional类型返回值直接由外部决定，不须要经过值从新封装为Optional实例：
public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper) {
// mapper存在性判断
Objects.requireNonNull(mapper);
// value为NULL，说明是空实例，则直接返回empty()
if (!isPresent()) {
return empty();
} else {
// value不为NULL，经过mapper转换，直接返回mapper的返回值，作一次空判断
@SuppressWarnings("unchecked")
Optional<U> r = (Optional<U>) mapper.apply(value);
return Objects.requireNonNull(r);
}
}
复制代码
例如：
class OptionalOrderFactory{
static Optional<Order> create(String id){
//省略...
}
}
String orderId = "xxx";
Optional<Order> op = Optional.of(orderId).flatMap(id -> OptionalOrderFactory.create(id));
复制代码
or()方法
public Optional<T> or(Supplier<? extends Optional<? extends T>> supplier) {
// supplier存在性判断
Objects.requireNonNull(supplier);
// value不为NULL，则直接返回自身
if (isPresent()) {
return this;
} else {
// value为NULL，则返回supplier提供的Optional实例，作一次空判断
@SuppressWarnings("unchecked")
Optional<T> r = (Optional<T>) supplier.get();
return Objects.requireNonNull(r);
}
}
复制代码
例如：
Order a = null;
Order b = select();
// 拿到的就是b订单实例包装的Optional
Optional<Order> op = Optional.ofNullable(a).or(b);
复制代码
stream()方法
// 对value作NULL判断，转换为Stream类型
public Stream<T> stream() {
if (!isPresent()) {
return Stream.empty();
} else {
return Stream.of(value);
}
}
复制代码
orElse()方法
// 值不为NULL则直接返回value，不然返回other
public T orElse(T other) {
return value != null ? value : other;
}
复制代码
orElse()就是常见的提供默认值兜底的方法，例如：
String v1 = null;
String v2 = "default";
// 拿到的就是v2对应的"default"值
String value = Optional.ofNullable(v1).orElse(v2);
复制代码
orElseGet()方法
// 值不为NULL则直接返回value，不然返回Supplier#get()
public T orElseGet(Supplier<? extends T> supplier) {
return value != null ? value : supplier.get();
}
复制代码
orElseGet()只是orElse()方法的升级版，例如：
String v1 = null;
Supplier<String> v2 = () -> "default";
// 拿到的就是v2对应的"default"值
String value = Optional.ofNullable(v1).orElseGet(v2);
复制代码
orElseThrow()方法
// 若是值为NULL，则抛出NoSuchElementException，不然直接返回value
public T orElseThrow() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
// 若是值不为NULL，则直接返回value，不然返回Supplier#get()提供的异常实例
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}
复制代码
例如：
Optional.ofNullable(orderInfoVo.getAmount()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId())));
复制代码
equals()和hashCode()方法
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Optional)) {
return false;
}
Optional<?> other = (Optional<?>) obj;
return Objects.equals(value, other.value);
}
public int hashCode() {
return Objects.hashCode(value);
}
复制代码
这两个方法都是比较value，说明了Optional实例若是使用于HashMap的KEY，只要value相同，对于HashMap就是同一个KEY。如：
Map<Optional,Boolean> map = new HashMap<>();
Optional<String> op1 = Optional.of("throwable");
map.put(op1, true);
Optional<String> op2 = Optional.of("throwable");
map.put(op2, false);
// 输出false
System.out.println(map.get(op1));
复制代码
Optional实战
下面展现一下Optional的一些常见的使用场景。
空判断
空判断主要是用于不知道当前对象是否为NULL的时候，须要设置对象的属性。不使用Optional时候的代码以下：
if(null != order){
order.setAmount(orderInfoVo.getAmount());
}
复制代码
使用Optional时候的代码以下：
Optional.ofNullable(order).ifPresent(o -> o.setAmount(orderInfoVo.getAmount()));
// 若是判断空的对象是OrderInfoVo以下
Order o = select();
OrderInfoVo vo = ...
Optional.ofNullable(vo).ifPresent(v -> o.setAmount(v.getAmount()));
复制代码
使用Optional实现空判断的好处是只有一个属性设值的时候能够压缩代码为一行，这样作的话，代码会相对简洁。
断言
在维护一些老旧的系统的时候，不少状况下外部的传参没有作空判断，所以须要写一些断言代码如：
if (null == orderInfoVo.getAmount()){
throw new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId()));
}
if (StringUtils.isBlank(orderInfoVo.getAddress()){
throw new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId()));
}
复制代码
使用Optional后的断言代码以下：
Optional.ofNullable(orderInfoVo.getAmount()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的amount不能为NULL",orderInfoVo.getOrderId())));
Optional.ofNullable(orderInfoVo.getAddress()).orElseThrow(()-> new IllegalArgumentException(String.format("%s订单的address不能为空",orderInfoVo.getOrderId())));
复制代码
综合仿真案例
下面是一个仿真案例，模拟的步骤以下：
- 给出客户ID列表查询客户列表。
- 基于存在的客户列表中的客户ID查询订单列表。
- 基于订单列表转换为订单DTO视图列表。
@Data
static class Customer {
private Long id;
}
@Data
static class Order {
private Long id;
private String orderId;
private Long customerId;
}
@Data
static class OrderDto {
private String orderId;
}
// 模拟客户查询
private static List<Customer> selectCustomers(List<Long> ids) {
return null;
}
// 模拟订单查询
private static List<Order> selectOrders(List<Long> customerIds) {
return null;
}
// main方法
public static void main(String[] args) throws Exception {
List<Long> ids = new ArrayList<>();
List<OrderDto> view = Optional.ofNullable(selectCustomers(ids))
.filter(cs -> !cs.isEmpty())
.map(cs -> selectOrders(cs.stream().map(Customer::getId).collect(Collectors.toList())))
.map(orders -> {
List<OrderDto> dtoList = new ArrayList<>();
orders.forEach(o -> {
OrderDto dto = new OrderDto();
dto.setOrderId(o.getOrderId());
dtoList.add(dto);
});
return dtoList;
}).orElse(Collections.emptyList());
}
复制代码
小结
Optional本质是一个对象容器，它的特征以下：
Optional做为一个容器承载对象，提供方法适配部分函数式接口，结合部分函数式接口提供方法实现NULL判断、过滤操做、安全取值、映射操做等等。Optional通常使用场景是用于方法返回值的包装，固然也能够做为临时变量从而享受函数式接口的便捷功能。Optional只是一个简化操做的工具，能够解决多层嵌套代码的节点空判断问题（例如简化箭头型代码）。Optional并不是银弹。
这里提到箭头型代码，下面尝试用常规方法和Optional分别解决：
// 假设VO有多个层级，每一个层级都不知道父节点是否为NULL，以下
// - OrderInfoVo
// - UserInfoVo
// - AddressInfoVo
// - address(属性)
// 假设我要为address属性赋值，那么就会产生箭头型代码。
// 常规方法
String address = "xxx";
OrderInfoVo o = ...;
if(null != o){
UserInfoVo uiv = o.getUserInfoVo();
if (null != uiv){
AddressInfoVo aiv = uiv.getAddressInfoVo();
if (null != aiv){
aiv.setAddress(address);
}
}
}
// 使用Optional
String address = "xxx";
OrderInfoVo o = null;
Optional.ofNullable(o)
.map(OrderInfoVo::getUserInfoVo)
.map(UserInfoVo::getAddressInfoVo)
.ifPresent(a -> a.setAddress(address));
复制代码
使用Optional解决箭头型代码，经过映射操做map()能减小大量的if和NULL判断分支，使得代码更加简洁。
有些开发者提议把DAO方法的返回值类型定义为Optional，笔者对此持中立态度，缘由是：
Optional是JDK1.8引入，低版本的JDK并不能使用，不是全部的系统都能平滑迁移到JDK1.8+。- 并非全部人都热衷于函数式编程，由于它带来了便捷的同时转变了代码的阅读逻辑（有些人甚至会认为下降了代码的可读性）。
附件
- Github Page：www.throwable.club/2019/08/07/…
- Coding Page：throwable.coding.me/2019/08/07/…
- Markdown或Asciidoc文件：github.com/zjcscut/blo…
（本文完 c-2-d e-a-20190805 by throwable）
相关文章
- 1. Java 8th 函数式编程：Optional 类型
- 2. java8 -函数式编程之Optional
- 3. Java函数式编程之Consumer和Predicate
- 4. Java 8函数式编程
- 5. java函数式编程
- 6. JAVA 函数式编程
- 7. java 函数式编程
- 8. Java 函数式编程
- 9. Java 函数式编程 ----函数接口
- 10. 函数式编程之 Python
- 更多相关文章...
- • Rust 并发编程 - RUST 教程
- • SQLite - Java - SQLite教程
- • Java 8 Stream 教程
- • Flink 数据传输及反压详解
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 在windows下的虚拟机中,安装华为电脑的deepin操作系统
- 2. 强烈推荐款下载不限速解析神器
- 3. 【区块链技术】孙宇晨：区块链技术带来金融服务的信任变革
- 4. 搜索引起的链接分析-计算网页的重要性
- 5. TiDB x 微众银行 | 耗时降低 58%，分布式架构助力实现普惠金融
- 6. 《数字孪生体技术白皮书》重磅发布（附完整版下载）
- 7. 双十一“避坑”指南：区块链电子合同为电商交易保驾护航！
- 8. 区块链产业，怎样“链”住未来？
- 9. OpenglRipper使用教程
- 10. springcloud请求一次好用一次不好用zuul Name or service not known
欢迎关注本站公众号,获取更多信息
相关文章
- 1. Java 8th 函数式编程：Optional 类型
- 2. java8 -函数式编程之Optional
- 3. Java函数式编程之Consumer和Predicate
- 4. Java 8函数式编程
- 5. java函数式编程
- 6. JAVA 函数式编程
- 7. java 函数式编程
- 8. Java 函数式编程
- 9. Java 函数式编程 ----函数接口
- 10. 函数式编程之 Python