共计 5289 个字符，预计需要花费 14 分钟才能阅读完成。
引言
在文章的结尾，先说下 NPE 问题，NPE 问题就是，咱们在开发中常常碰到的 NullPointerException. 假如咱们有两个类，他们的 UML 类图如下图所示
在这种状况下，有如下代码：
user.getAddress().getProvince();这种写法，在 user 为 null 时，是有可能报 NullPointerException 异样的。为了解决这个问题，于是采纳上面的写法：
if(user!=null){Address address = user.getAddress();
if(address!=null){String province = address.getProvince();
}
}这种写法是比拟俊俏的，为了防止上述俊俏的写法，让俊俏的设计变得优雅。JAVA8 提供了 Optional 类来优化这种写法，接下来的注释局部进行具体阐明
API 介绍
先介绍一下 API，与其余文章不同的是，本文采取类比的形式来讲，同时联合源码。而不像其余文章一样，一个个 API 列举进去，让人找不到重点。
1、Optional(T value),empty(),of(T value),ofNullable(T value)
这四个函数之间具备相关性，因而放在一组进行记忆。
先阐明一下，Optional(T value)，即构造函数，它是 private 权限的，不能由内部调用的。其余三个函数是 public 权限，供咱们所调用。那么，Optional 的实质，就是外部贮存了一个实在的值，在结构的时候，就直接判断其值是否为空。好吧，这么说还是比拟形象。间接上 Optional(T value) 构造函数的源码，如下图所示
那么，of(T value) 的源码如下：
public static <T> Optional<T> of(T value) {return new Optional<>(value);
}也就是说 of(T value) 函数外部调用了构造函数。依据构造函数的源码咱们能够得出两个论断:
- 通过 of(T value) 函数所结构出的 Optional 对象，当 Value 值为空时，仍然会报 NullPointerException。
- 通过 of(T value) 函数所结构出的 Optional 对象，当 Value 值不为空时，能失常结构 Optional 对象。
除此之外呢，Optional 类外部还保护一个 value 为 null 的对象，大略就是长上面这样的
public final class Optional<T> {
// 省略....
private static final Optional<?> EMPTY = new Optional<>();
private Optional() {this.value = null;}
// 省略...
public static<T> Optional<T> empty() {@SuppressWarnings("unchecked")
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
}那么，empty（）的作用就是返回 EMPTY 对象。
好了铺垫了这么多，能够说 ofNullable(T value) 的作用了，上源码
public static <T> Optional<T> ofNullable(T value) {return value == null ? empty() : of(value);
}好吧，大家应该都看得懂什么意思了。相比拟 of(T value) 的区别就是，当 value 值为 null 时，of(T value) 会报 NullPointerException 异样；ofNullable(T value) 不会 throw Exception，ofNullable(T value) 间接返回一个 EMPTY 对象。
那是不是意味着，咱们在我的项目中只用 ofNullable 函数而不必 of 函数呢?
不是的，一个货色存在那么天然有存在的价值。当咱们在运行过程中，不想暗藏 NullPointerException。而是要立刻报告，这种状况下就用 Of 函数。然而不得不抵赖，这样的场景真的很少。博主也仅在写 junit 测试用例中用到过此函数。
2、orElse(T other)，orElseGet(Supplier<? extends T> other) 和 orElseThrow(Supplier<? extends X> exceptionSupplier)
这三个函数放一组进行记忆，都是在构造函数传入的 value 值为 null 时，进行调用的。orElse 和 orElseGet 的用法如下所示，相当于 value 值为 null 时，给予一个默认值:
@Test
public void test() {
User user = null;
user = Optional.ofNullable(user).orElse(createUser());
user = Optional.ofNullable(user).orElseGet(() -> createUser());
}
public User createUser(){User user = new User();
user.setName("zhangsan");
return user;
}这两个函数的区别：当 user 值不为 null 时，orElse 函数仍然会执行 createUser() 办法，而 orElseGet 函数并不会执行 createUser() 办法，大家可自行测试。
至于 orElseThrow，就是 value 值为 null 时, 间接抛一个异样进来，用法如下所示
User user = null;
Optional.ofNullable(user).orElseThrow(()->new Exception("用户不存在"));3、map(Function<? super T, ? extends U> mapper) 和 flatMap(Function<? super T, Optional> mapper)
这两个函数放在一组记忆，这两个函数做的是转换值的操作。
间接上源码
public final class Optional<T> {
// 省略....
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));
}
}
// 省略...
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));
}
}
}这两个函数，在函数体上没什么区别。惟一区别的就是入参，map 函数所承受的入参类型为 Function<? super T, ? extends U>，而 flapMap 的入参类型为 Function<? super T, Optional<U>>。
在具体用法上，对于 map 而言：
如果 User 构造是上面这样的
public class User {
private String name;
public String getName() {return name;}
}这时候取 name 的写法如下所示
String city = Optional.ofNullable(user).map(u-> u.getName()).get();对于 flatMap 而言:
如果 User 构造是上面这样的
public class User {
private String name;
public Optional<String> getName() {return Optional.ofNullable(name);
}
}这时候取 name 的写法如下所示
String city = Optional.ofNullable(user).flatMap(u-> u.getName()).get();4、isPresent() 和 ifPresent(Consumer<? super T> consumer)
这两个函数放在一起记忆，isPresent 即判断 value 值是否为空，而 ifPresent 就是在 value 值不为空时，做一些操作。这两个函数的源码如下
public final class Optional<T> {
// 省略....
public boolean isPresent() {return value != null;}
// 省略...
public void ifPresent(Consumer<? super T> consumer) {if (value != null)
consumer.accept(value);
}
}须要额定阐明的是，大家千万不要把
if (user != null){// TODO: do something}给写成
User user = Optional.ofNullable(user);
if (Optional.isPresent()){// TODO: do something}因为这样写，代码构造仍然俊俏。博主会在前面给出正确写法
至于 ifPresent(Consumer<? super T> consumer)，用法也很简略，如下所示
Optional.ofNullable(user).ifPresent(u->{// TODO: do something});5、filter(Predicate<? super T> predicate)
不多说，间接上源码
public final class Optional<T> {
// 省略....
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();}filter 办法承受一个 Predicate 来对 Optional 中蕴含的值进行过滤，如果蕴含的值满足条件，那么还是返回这个 Optional；否则返回 Optional.empty。
用法如下
Optional<User> user1 = Optional.ofNullable(user).filter(u -> u.getName().length()<6);如上所示，如果 user 的 name 的长度是小于 6 的，则返回。如果是大于 6 的，则返回一个 EMPTY 对象。
实战应用
例一
在函数办法中
以前写法
public String getCity(User user) throws Exception{if(user!=null){if(user.getAddress()!=null){Address address = user.getAddress();
if(address.getCity()!=null){return address.getCity();
}
}
}
throw new Excpetion("取值谬误");
}JAVA8 写法
public String getCity(User user) throws Exception{return Optional.ofNullable(user)
.map(u-> u.getAddress())
.map(a->a.getCity())
.orElseThrow(()->new Exception("取指谬误"));
}例二
比方，在主程序中
以前写法
if(user!=null){dosomething(user);
}JAVA8 写法
Optional.ofNullable(user)
.ifPresent(u->{dosomething(u);
});例三
以前写法
public User getUser(User user) throws Exception{if(user!=null){String name = user.getName();
if("zhangsan".equals(name)){return user;}
}else{user = new User();
user.setName("zhangsan");
return user;
}
}java8 写法
public User getUser(User user) {return Optional.ofNullable(user)
.filter(u->"zhangsan".equals(u.getName()))
.orElseGet(()-> {User user1 = new User();
user1.setName("zhangsan");
return user1;
});
}其余的例子，不一一列举了。不过采纳这种链式编程，尽管代码优雅了。然而，逻辑性没那么显著，可读性有所升高，大家我的项目中看状况酌情应用。
起源：blog.csdn.net/zjhred/article/details/84976734
