前言
最近脑袋发热追着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
查看更多关于java8新特性之Optional的深入解析的详细内容...