java8新特性之Optional的深入解析

时间:2022-08-31 20:59:57

前言

最近脑袋发热追着java8源码看的很起劲,还有了执念,罪过。

本文以jdk1.8.0_111源码为例

?
1
public final class optional<t> {}

optional是一个为了解决nullpointerexception设计而生可以包含对象也可以包含空的容器对象。封装了很多对空处理的方法也增加了filter、map这样的检索利器,其中函数式编程会有种炫酷到爆的感觉。

基础测试用例对象:

?
1
2
3
4
5
6
7
8
public class java8optionaltest {
 list<string> stringlist = null;
 icar car = new weilaicar();
}
 
public class weilaicar implements icar {
 integer wheels = new integer(4);

api中提供的4种optional

最核心的当属optional对象,泛型的引入支持了所有对象类型,又增加对常用场景下的dubbo\int\long进行扩展。重点介绍一下optional对象的方法其他三个类似。

  • public final class optional<t> {
  • public final class optionaldouble {
  • public final class optionalint {
  • public final class optionallong {

@functionalinterface
predicate\consumer\supplier三个接口都是函数式接口

静态方法of

?
1
2
3
private optional() {
 this.value = null;
}

构造方法被private,不能new但提供了of这样的静态方法去初始化类;

?
1
2
3
4
5
6
7
8
9
10
11
public static <t> optional<t> of(t value) {
 return new optional<>(value);
}
public static <t> optional<t> ofnullable(t value) {
 return value == null ? empty() : of(value);
}
public static<t> optional<t> empty() {
 @suppresswarnings("unchecked")
 optional<t> t = (optional<t>) empty;
 return t;
}

1、empty支持你去创建一个空的optional类,这样的类直接get()会报错:java.util.nosuchelementexception: no value present

2、of(x)传入的对象不能为null,而ofnullable(x)是支持传入null的对象,一般用这两个比较多。

present 方法

ispresent是用来判断optional中对象是否为null,ifpresent的参数是当对象不为null时执行的lamdba表达式。

?
1
2
3
4
5
6
7
public boolean ispresent() {
 return value != null;
}
public void ifpresent(consumer<? super t> consumer) {
 if (value != null)
 consumer.accept(value);
}

示例详解介绍了ifpresent特性:

?
1
2
3
4
5
6
7
8
9
10
11
12
java8optionaltest test = new java8optionaltest();
optional<java8optionaltest> optional = optional.of(test);
 
pringtest(optional.ispresent());
//true
optional.ifpresent( a -> pringtest(a.getcar().getclass().getname()));
//com.ts.util.optional.weilaicar
optional.ifpresent( a -> optional.ofnullable(a.getstringlist()).ifpresent(b -> pringtest("stringlist:" + (b == null))));
//第一级的ifpresent是存在test对象,所以执行了lambda表达式,而第二级的ifpresent的stringlist是null,所以没有执行表达式
optional.ifpresent( a -> optional.ofnullable(a.getcar()).ifpresent(b -> pringtest("car:" + (b == null))));
//car:false
//第二级ifpresent的car对象是存在的,所以第二级的表达式执行了

map 方法

源码提供了两种map和flatmap。

  • map方法的参数是个当包含的对象不为null时才执行的lambda表达式,返回该表达式执行结果的封装optional对象,同理支持链式调用,逐层深入和递归递进很像;
  • flatmap区别在于lambda表达式的返回结果必须主动包裹optinoal,否则报错
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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));
 }
}

测试示例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
java8optionaltest test = new java8optionaltest();
optional<java8optionaltest> optional = optional.of(test);
 
optional opt1 = optional.map( a -> a.getcar());
pringtest(opt1.get());
//com.ts.util.optional.weilaicar@5d6f64b1
int wheel = 0;//传统null判断写法
if(test != null){
 if(test.getcar() != null){//实际业务里面层级也许会超过3层
  wheel = test.getcar().getwheelcount();
 }
}
pringtest("传统:"+wheel);
//传统:4
optional opt2 = optional.map( a -> a.getcar()).map(b -> b.getwheelcount());//optional支持下的写法
pringtest("optinal:"+opt2.get());
//optinal:4
optional opt3 = optional.map( a -> a.getstringlist()).map(b -> b.size());
pringtest(opt3);
//optional.empty
 
optional opt4 = optional.flatmap(a -> optional.of(a.getcar()));//主动包裹optional对象
pringtest(opt4);
//optional[com.ts.util.optional.weilaicar@5d6f64b1]
optional opt5 = optional.flatmap(a -> optional.of(a.getcar())).flatmap(b -> optional.ofnullable(b.getwheelcount()));
pringtest(opt5);
//optional[4]

filter 方法

源码如下:

?
1
2
3
4
5
6
7
public optional<t> filter(predicate<? super t> predicate) {
 objects.requirenonnull(predicate);
 if (!ispresent())
  return this;
 else
  return predicate.test(value) ? this : empty();
}

filter方法传入一个断言语句条件的lambda表达式,返回一个原对象的optional包装,所以支持链式调用;只要记住这三点你便掌握如何使用了。

看下面的例子:

?
1
2
3
4
5
6
7
8
9
10
java8optionaltest test = new java8optionaltest();
 
optional<java8optionaltest> optional = optional.of(test);
 
optional result = optional.filter( a -> a.getcar() != null).filter( b -> b.getclass().getname() != null);
pringtest(result.ispresent()? result.get().getclass().getname(): result.ispresent());
//com.ts.util.java8optionaltest
optional result1 = optional.filter( a -> a.getstringlist() != null);
pringtest(result1.get());
//java.util.nosuchelementexception: no value present

orelse 方法

api提供了三个方法。

  • orelse 当optional内对象为null就返回这个参数,比较像很多默认值设置;
  • orelseget 基本同orelse,区别是传入参数支持lambda表达式,返回的就是表达式执行结果;
  • orelsethrow 也是传入lambda表达式,但是表达式是抛出异常
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public t orelse(t other) {
 return value != null ? value : other;
}
 
public t orelseget(supplier<? extends t> other) {
 return value != null ? value : other.get();
}
 
public <x extends throwable> t orelsethrow(supplier<? extends x> exceptionsupplier) throws x {
 if (value != null) {
  return value;
 } else {
  throw exceptionsupplier.get();
 }
}

测试用例如下:

?
1
2
3
4
5
6
7
8
9
10
11
java8optionaltest one = null;
java8optionaltest test = new java8optionaltest();
optional<java8optionaltest> optional = optional.ofnullable(one);
pringtest(optional);
//optional.empty
pringtest(optional.orelse(test));
//com.ts.util.java8optionaltest@5197848c
pringtest(optional.orelseget(() -> new java8optionaltest()));
//com.ts.util.java8optionaltest@5d6f64b1
pringtest(optional.orelsethrow(() -> new runtimeexception("orelsethrow")));
//java.lang.runtimeexception: orelsethrow

总结

官方推出optional绝不会就是替大家判断一下null,filter\map\orelse这三种使用场景是比较容易想到的,很多业务场景需要慢慢摸索使用。多函数式的用法需要好好掌握,技术发展是非常快速的。

后面会专门开一篇讲函数式和lambda表达式用法,保持好奇心关注我的博客。

好了,以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对服务器之家的支持。

原文链接:https://blog.shareworld.vip/article/optional01