JAVA8之妙⽤Optional解决判断Null为空的问题
引⾔
在⽂章的开头，先说下NPE问题，NPE问题就是，我们在开发中经常碰到的NullPointerException.假设我们有两个类，他们的UML类图如下图所⽰
在这种情况下，有如下代码
这种写法，在user为null时，是有可能报NullPointerException异常的。为了解决这个问题，于是采⽤下⾯的写法
if(user!=null){
Address address = Address();
if(address!=null){
String province = Province();
}
}
这种写法是⽐较丑陋的，为了避免上述丑陋的写法，让丑陋的设计变得优雅。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<U>> mapper)
这两个函数放在⼀组记忆，这两个函数做的是转换值的操作。
直接上源码
public final class Optional<T> {
//省略....
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
if (!isPresent())
return empty();
else {
return Optional.ofNullable(mapper.apply(value));
}
}
//省略...
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
if (!isPresent())
return empty();
else {
quireNonNull(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)
function怎么记忆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> {
//省略....
if (!isPresent())
return this;
else
st(value) ? this : empty();
}
filter ⽅法接受⼀个 Predicate 来对 Optional 中包含的值进⾏过滤，如果包含的值满⾜条件，那么还是返回这个 Optional；否则返
回 pty。
⽤法如下
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){
Address()!=null){
Address address = Address();
City()!=null){
City();
}
}
}
throw new Excpetion("取值错误");
}
JAVA8写法
public String getCity(User user) throws Exception{
return Optional.ofNullable(user)
.map(u-> u.getAddress())
.
map(a-&City())
.orElseThrow(()->new Exception("取指错误"));
}
例⼆
⽐如，在主程序中
以前写法
if(user!=null){
dosomething(user);
}
JAVA8写法
Optional.ofNullable(user)
.
ifPresent(u->{
dosomething(u);
});
例三
以前写法
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论