Optional用于包含非空对象的容器对象。Optional对象，用于表示使用不存在null值。这个类有各种实用的方法，以方便代码来处理为可用或不可用，而不是检查null值。它是Java引入, 是类似于在&&中的&&。
以下是java.util.Optional&T&类的声明：
public final class Optional&T&
extends Object
方法及说明
static &T& Optional&T& empty()
返回一个空的 Optional 实例。
boolean equals(Object obj)
表示某个其他对象是否&等于&此Optional。
Optional&T& filter(Predicate&? super T& predicate)&
如果值存在，并且该值给定的谓词匹配，返回一个可选描述值，否则返回一个空Optional。
&U& Optional&U& flatMap(Function&? super T,Optional&U&& mapper)
如果值存在，应用提供的可选承载映射功能到它，返回结果，否则返回一个空Optional。
如果值是出现在这个 Optional 中，返回这个值，否则抛出NoSuchElementException异常。
int hashCode()
返回当前值，哈希码值（如有）或0（零），如果值不存在。
void ifPresent(Consumer&? super T& consumer)
如果值存在，调用指定的使用方提供值，否则什么都不做。
boolean isPresent()
返回true，如果有一个值存在，否则为false。
&U& Optional&U& map(Function&? super T,? extends U& mapper)
如果值存在，应用提供的映射函数，如果结果非空，返回一个Optional描述结果。
static &T& Optional&T& of(T value)
返回一个Optional具有指定当前非空值。
static &T& Optional&T& ofNullable(T value)
返回一个Optional描述指定的值，如果非空，否则返回一个空的Optional。
T orElse(T other)
返回值（如果存在），否则返回other。
T orElseGet(Supplier&? extends T& other)
如果存在，返回值，否则调用其他并返回调用的结果。
&X extends Throwable& T orElseThrow(Supplier&? extends X& exceptionSupplier)
返回所含值，如果存在的话，否则抛出将由提供者创建的一个例外。
String toString()
返回此Optional适合调试一个非空字符串表示。
这个类从以下类继承的方法：
java.lang.Object
Optional 例子
选择使用任何编辑器创建以下java程序在&C:/& JAVA
Java8Tester.java
import java.util.Optional;
public class Java8Tester {
public static void main(String args[]){
Java8Tester java8Tester = new Java8Tester();
Integer value1 =
Integer value2 =
new Integer(10);
//Optional.ofNullable - allows passed parameter to be null.
Optional&Integer& a = Optional.ofNullable(value1);
//Optional.of - throws NullPointerException if passed parameter is null
Optional&Integer& b = Optional.of(value2);
System.out.println(java8Tester.sum(a,b));
public Integer sum(Optional&Integer& a, Optional&Integer& b){
//Optional.isPresent - checks the value is present or not
System.out.println(&First parameter is present: & + a.isPresent());
System.out.println(&Second parameter is present: & + b.isPresent());
//Optional.orElse - returns the value if present otherwise returns
//the default value passed.
Integer value1 = a.orElse(new Integer(0));
//Optional.get - gets the value, value should be present
Integer value2 = b.get();
return value1 + value2;
使用javac编译器编译如下类
C:\JAVA&javac Java8Tester.java
现在运行Java8Tester看到的结果
C:\JAVA&java Java8Tester
看到结果。
First parameter is present: false
Second parameter is present: true
加QQ群啦！
JAVA技术群(2000人群)：
MySQL/SQL群(2000人群)：
Python技术群(2000人群)：
大数据开发群(2000人群)： (Java,Python,R,Scala,Hadoop,Spark,zookeeper,kafka等技术)
Web开发群(新群):
(PHP,HTML/HTML5,JS/JQuery,CSS等技术)
Linux技术群(新群): (Redhat/Centos,Ubuntu,Shell,运维,监控等技术)
人工智能&深度学习(新群):
(人工智能，深度学习，算法等技术)
易百教程移动端：请扫描本页面底部(右侧)二维码关注微信公众号，或直接手机访问：
上一篇：下一篇：Java8 中Optional类的使用 - CSDN博客
Java8 中Optional类的使用
1、利用Optional 提取Json中的某个字段的值, 本例子程序提取 sku 的值
import com.jd.fastjson.JSONA
import com.jd.fastjson.JSONO
import org.junit.T
import java.util.O
* @author: wangyingjie1
* @version: 1.0
* @createdate:
public class OptionalTest {
public void testOptionalGetValue() {
//利用Optional 提取Json中的某个字段的值, 本例子程序提取 sku 的值
String json = "{\n" +
\"code\": \"0\",\n" +
\"result\": \"Success\",\n" +
\"data\": {\n" +
\"totalCount\": 10,\n" +
\"resultData\": [\n" +
\"sku\": ,\n" +
\"name\": \"博世（BOSCH）机油滤清器 机油格 机滤 机油滤芯 新领驭 1.8T (09-10款)\",\n" +
\"accyModelId\": 28489,\n" +
\"cid1\": 6728,\n" +
\"cid2\": 6742,\n" +
\"cid3\": 11852,\n" +
\"venderId\": 111655,\n" +
\"brandId\": 5125,\n" +
\"venderName\": \"上海硕泽实业有限公司\",
\"modelIds\": null,\n" +
\"carButlerCatIds\": [\n" +
\"foot\": {\n" +
\"operationTime\": \" 11:18:10\",\n" +
\"version\": \"1.0.0\",\n" +
\"clientVersion\": null,\n" +
\"client\": null,\n" +
\"osVersion\": null\n" +
Long sku = Optional.ofNullable(json)
.map(JSONObject::parseObject)
.map(jsonObject -& jsonObject.getJSONObject("data"))
.map(jsonObject -& jsonObject.getJSONArray("resultData"))
.flatMap(jsonArr -& convertJsonStrToJsonObjectStream(jsonArr))
System.out.println("sku============" + sku);
private Optional&Long& convertJsonStrToJsonObjectStream(JSONArray jsonArr) {
return jsonArr.stream()
.map(obj -& (JSONObject) obj)
.findFirst()
.map(obj -& obj.getLong("sku"))
本文已收录于以下专栏：
相关文章推荐
作者：Joan
出处：/Joans/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否...
Java8自定义函数
package com.jd.svc.jdk8;import java.util.function.BiC
import java.util.function.B...
Java8–Optional使用范例标签（空格分隔）： javaOptional是一个对象包装容器,这个类很简单,学习该工具类的最好方法就是看源码,看完后相信你会对该类有足够的底气使用.
下面是一些...
身为一名Java程序员，大家可能都有这样的经历：调用一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。我们首先要判断这个返回值是否为null，只有在非空的前提下才能将其作为其他方法的参数。...
原文地址：/6675.html
身为一名Java程序员，大家可能都有这样的经历：调用一个方法得到了返回值却不能直接将返回值作为参数去调...
Java8中加入的Optional类的主要作用是，为了让我们在编程中尽量去规避空指针异常。
我仅仅是为了让自己对学习Optional类的记忆更加深刻而写这边博客，其实它很简单，可工作中还没用到Java...
如果你开发过Java程序，可能会有过这样的经历：调用某种数据结构的一个方法得到了返回值却不能直接将返回值作为参数去调用别的方法。而是首先判断这个返回值是否为null，只有在非空的前提下才能将其作为其他...
在Java中，null代表一个不存在的对象，如果对它进行操作就会抛出java.lang.NullPointerException异常。NPE（NullPointerException）是调试程序最常见...
我们知道 JAVA 8 增加了一些很有用的 API，其中一个就是 Optional。如果对它不加以思索，只是轻描淡写的认为它优雅的解决了 NullPointException 的问题，于是就开始这样编...
1. Optional类的简介Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。Optional 是个容器：它可...
他的最新文章
讲师：董岩
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)使用 Java8 Optional 的正确姿势 - ImportNew
| 标签： ,
我们知道 Java 8 增加了一些很有用的 API, 其中一个就是 Optional. 如果对它不稍假探索, 只是轻描淡写的认为它可以优雅的解决 NullPointException 的问题, 于是代码就开始这么写了
Optional&User& user = ……
if (user.isPresent()) {
return user.getOrders();
return Collections.emptyList();
那么不得不说我们的思维仍然是在原地踏步, 只是本能的认为它不过是 User 实例的包装, 这与我们之前写成
User user = …..
if (user != null) {
return user.getOrders();
return Collections.emptyList();
实质上是没有任何分别. 这就是我们将要讲到的使用好 Java 8 Optional 类型的正确姿势.
在里约奥运之时, 新闻一再提起五星红旗有问题, 可是我怎么看都看不出来有什么问题, 后来才道是小星星膜拜中央的姿势不对. 因此我们千万也别对自己习以为常的事情觉得理所当然, 丝毫不会觉得有何不妥, 换句话说也就是当我们切换到 Java 8 的 Optional 时, 不能继承性的对待过往 null 时的那种思维, 应该掌握好新的, 正确的使用 Java 8 Optional 的正确姿势.
直白的讲, 当我们还在以如下几种方式使用 Optional 时, 就得开始检视自己了
调用 isPresent() 方法时
调用 get() 方法时
Optional 类型作为类/实例属性时
Optional 类型作为方法参数时
isPresent() 与 obj != null 无任何分别, 我们的生活依然在步步惊心. 而没有 isPresent() 作铺垫的 get() 调用在 IntelliJ IDEA 中会收到告警
Reports calls to java.util.Optional.get() without first checking with a isPresent() call if a value is available. If the Optional does not contain a value, get() will throw an exception. (调用 Optional.get() 前不事先用 isPresent() 检查值是否可用. 假如 Optional 不包含一个值, get() 将会抛出一个异常)
把 Optional 类型用作属性或是方法参数在 IntelliJ IDEA 中更是强力不推荐的
Reports any uses of java.util.Optional&T&, java.util.OptionalDouble, java.util.OptionalInt, java.util.OptionalLong or mon.base.Optional as the type for a field or a parameter. Optional was designed to provide a limited mechanism for library method return types where there needed to be a clear way to represent “no result”. Using a field with type java.util.Optional is also problematic if the class needs to be Serializable, which java.util.Optional is not. (使用任何像 Optional 的类型作为字段或方法参数都是不可取的. Optional 只设计为类库方法的, 可明确表示可能无值情况下的返回类型. Optional 类型不可被序列化, 用作字段类型会出问题的)
所以 Optional 中我们真正可依赖的应该是除了 isPresent() 和 get() 的其他方法:
public&U& Optional&U& map(Function&? super T, ? extends U& mapper)
public T orElse(T other)
public T orElseGet(Supplier&? extends T& other)
public void ifPresent(Consumer&? super T& consumer)
public Optional&T& filter(Predicate&? super T& predicate)
public&U& Optional&U& flatMap(Function&? super T, Optional&U&& mapper)
public &X extends Throwable& T orElseThrow(Supplier&? extends X& exceptionSupplier) throws X
我略有自信的按照它们大概使用频度对上面的方法排了一下序.
先又不得不提一下 Optional 的三种构造方式: Optional.of(obj),
Optional.ofNullable(obj) 和明确的 Optional.empty()
Optional.of(obj): 它要求传入的 obj 不能是 null 值的, 否则还没开始进入角色就倒在了 NullPointerException 异常上了.
Optional.ofNullable(obj): 它以一种智能的, 宽容的方式来构造一个 Optional 实例. 来者不拒, 传 null 进到就得到 Optional.empty(), 非 null 就调用 Optional.of(obj).
那是不是我们只要用 Optional.ofNullable(obj) 一劳永逸, 以不变应二变的方式来构造 Optional 实例就行了呢? 那也未必, 否则 Optional.of(obj) 何必如此暴露呢, 私有则可?
我本人的观点是:
1. 当我们非常非常的明确将要传给 Optional.of(obj) 的 obj 参数不可能为 null 时, 比如它是一个刚 new 出来的对象(Optional.of(new User(...))), 或者是一个非 null 常量时;
2. 当想为 obj 断言不为 null 时, 即我们想在万一 obj 为 null 立即报告 NullPointException 异常, 立即修改, 而不是隐藏空指针异常时, 我们就应该果断的用 Optional.of(obj) 来构造 Optional 实例, 而不让任何不可预计的 null 值有可乘之机隐身于 Optional 中.
现在才开始怎么去使用一个已有的 Optional 实例, 假定我们有一个实例 Optional&User& user, 下面是几个普遍的, 应避免 if(user.isPresent()) { ... } else { ... } 几中应用方式.
存在即返回, 无则提供默认值
return user.orElse(null);
//而不是 return user.isPresent() ? user.get() :
return user.orElse(UNKNOWN_USER);
存在即返回, 无则由函数来产生
return user.orElseGet(() -& fetchAUserFromDatabase()); //而不要 return user.isPresent() ? user: fetchAUserFromDatabase();
存在才对它做点什么
user.ifPresent(System.out::println);
//而不要下边那样
if (user.isPresent()) {
System.out.println(user.get());
map 函数隆重登场
当 user.isPresent() 为真, 获得它关联的 orders, 为假则返回一个空集合时, 我们用上面的 orElse, orElseGet 方法都乏力时, 那原本就是 map 函数的责任, 我们可以这样一行
return user.map(u -& u.getOrders()).orElse(Collections.emptyList())
//上面避免了我们类似 Java 8 之前的做法
if(user.isPresent()) {
return user.get().getOrders();
return Collections.emptyList();
是可能无限级联的, 比如再深一层, 获得用户名的大写形式
return user.map(u -& u.getUsername())
.map(name -& name.toUpperCase())
.orElse(null);
这要搁在以前, 每一级调用的展开都需要放一个 null 值的判断
User user = .....
if(user != null) {
String name = user.getUsername();
if(name != null) {
return name.toUpperCase();
针对这方面 Groovy 提供了一种安全的属性/方法访问操作符 ?.
user?.getUsername()?.toUpperCase();
Swift 也有类似的语法, 只作用在
Optional 的类型上.
用了 isPresent() 处理 NullPointerException 不叫优雅, 有了
orElse, orElseGet 等, 特别是 map 方法才叫优雅.
其他几个, filter() 把不符合条件的值变为 empty(),
flatMap() 总是与 map() 方法成对的,
orElseThrow() 在有值时直接返回, 无值时抛出想要的异常.
一句话小结: 使用 Optional 时尽量不直接调用 Optional.get() 方法, Optional.isPresent() 更应该被视为一个私有方法, 应依赖于其他像 Optional.orElse(), Optional.orElseGet(), Optional.map() 等这样的方法.
最后, 最好的理解 Java 8 Optional 的方法莫过于看它的源代码, 阅读了源代码才能真真正正的让你解释起来最有底气, Optional 的方法中基本都是内部调用
isPresent() 判断, 真时处理值, 假时什么也不做.
文章很好，我先收藏了，谢谢
关于ImportNew
ImportNew 专注于 Java 技术分享。于日 11:11正式上线。是的，这是一个很特别的时刻 :)
ImportNew 由两个 Java 关键字 import 和 new 组成，意指：Java 开发者学习新知识的网站。 import 可认为是学习和吸收， new 则可认为是新知识、新技术圈子和新朋友……
新浪微博：
推荐微信号
反馈建议：@
广告与商务合作QQ：
– 好的话题、有启发的回复、值得信赖的圈子
– 写了文章？看干货？去头条！
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 活跃 & 专业的翻译小组
– 国内外的精选博客文章
– UI,网页，交互和用户体验
– JavaScript, HTML5, CSS
– 专注Android技术分享
– 专注iOS技术分享
– 专注Java技术分享
– 专注Python技术分享
& 2017 ImportNew2556人阅读
莫若吻``学 _ Java（30）
Java 类库的新特性之 Optional类
文 | 莫若吻
1.Optional简述&
到目前为止，著名的NullPointerException是导致Java应用程序失败的最常见原因。过去，为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码。如今，受到Google Guava的启发，Optional类已经成为Java 8类库的一部分。
Optional：按照字面英文解释为“可选的” 意思，但此处的语义是指某个值可能有也可能没有（null）。
Optional 被定义为一个简单的容器，其值可能是null或者不是null。在Java 8之前一般某个函数应该返回非空对象但是偶尔却可能返回了null，而在Java 8 以后，不推荐你返回null而是返回Optional。
英文文档地址：
2.对&Optional 应用的理解
Java 8借鉴了Scala和Haskell，提供了一个新的Optional模板，可以用它来封装可能为空的引用。但它绝不是终结空指针，更多只是使API的设计者可以在代码层面声明一个方法可能会返回空值，调用方应该注意这种情况。因此，这只对新的API有效，前提是调用者不要让引用逃逸出封装类，否则引用可能会在外面被不安全的废弃掉。
个人对这个新的特性是又爱又恨。一方面，空指针是一个大问题，只要能解决这个问题的东西笔者都欢迎。但另一方面，个人对它是否能担此重任执怀疑的态度。这是由于使用它需要全公司的集体努力，短期内很难会有见效。若非大力地推广使用，很可能会功亏一篑。
3.Optional的优点
1）显式的提醒你需要关注null的情况，对程序员是一种字面上的约束
2）将平时的一些显式的防御性检测给标准化了，并提供一些可串联操作
3）解决null会导致疑惑的概念
eg：Map里面的key==null的情况，以及value==null的情况
4.Optional类
4.1&Optional类的官方描述
A container object which may or may not contain a non-null value.&If
a value is present,&isPresent()&will return&true&and&get()&will return the value.
（这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。）
4.2&Optional的简单使用
Optional类的包名：java.util.Optional&T&
为了防止抛出java.lang.NullPointerException&异常，我们经常会写出这样的代码：
Student student = person.find(&Lucy&);
if (student != null) {
student.doSomething();
使用Optional的代码写法：
Student student = person.find(&Lucy&);
if (student.isPresent()) {
student.get().doSomething();
}说明：如果isPresent()返回false，说明这是个空对象；否则，我们就可以把其中的内容取出来做相应的操作了。
单从代码量上来说，Optional的代码量并未减少，甚至比原来的代码还多。但好在，你绝对不会忘记判空，因为这里我们得到的不是Student类的对象，而是Optional。
4.3Optional类的主要方法
1) of(T value)
为非null的值创建一个Optional。
of()方法通过工厂方法创建Optional类。需要注意，创建对象时传入的参数不能为null。如果传入参数为null，则抛出NullPointerException 。
//调用工厂方法创建Optional实例
Optional&String& myValue = Optional.of(&OptionalTest&);
//传入参数为null，抛出NullPointerException.
Optional&String& someNull = Optional.of(null);
2)&ofNullable(T value)
为指定的值创建一个Optional，如果指定的值为null，则返回一个空的Optional。
ofNullable与of方法相似，唯一的区别是可以接受参数为null的情况。
//下面创建了一个不包含任何值的Optional实例
//eg:值为'null'
Optional empty = Optional.ofNullable(null);
<span style="color:#)&isPresent()
如果值存在返回true，否则返回false。
//isPresent()方法用来检查Optional实例中是否包含值
if (myValue.isPresent()) {
//在Optional实例内调用get()返回已存在的值
System.out.println(myValue.get());//输出OptionalTest }
<span style="color:#)&get()
如果Optional有值则将其返回，否则抛出异常&NoSuchElementException。
在上面的示例中，get方法用来得到Optional实例中的值。下面是一个抛出NoSuchElementException的示例：
//执行下面的代码会输出：No value present
//在空的Optional实例上调用get()，抛出NoSuchElementException
System.out.println(empty.get());
} catch (NoSuchElementException ex) {
System.out.println(ex.getMessage());
5)&ifPresent(Consumer&?
super T& consumer)
如果Optional实例有值则为其调用consumer，否则不做处理。
要理解ifPresent()方法，首先需要了解Consumer类。简单地说，Consumer类包含一个抽象方法。该抽象方法对传入的值进行处理，但没有返回值。Java8支持不用接口直接通过lambda表达式传入参数。
如果Optional实例有值，调用ifPresent()可以接受接口段或lambda表达式。
//ifPresent()方法接受lambda表达式作为参数。
//lambda表达式对Optional的值调用consumer进行处理。
myValue.ifPresent((value) -& {
System.out.println(&The length of the value is: & + value.length());
6)&orElse(T other)
如果有值则将其返回，否则返回指定的其它值。
如果Optional实例有值则将其返回，否则返回orElse方法传入的参数。即：参数other为默认返回值
//如果值不为null，orElse方法返回Optional实例的值。
//如果为null，返回传入的消息。
//输出：There is no value present!
System.out.println(empty.orElse(&There is no value present!&));
//输出：OptionalTest
System.out.println(myValue.orElse(&There is some value!&));
7)&orElseGet(Supplier&? extends T& other)
orElseGet与orElse方法类似，区别在于得到的默认值。orElse方法将传入的参数字符串作为默认值，orElseGet方法可以接受Supplier接口的实现用来生成默认值。
//orElseGet可以接受一个lambda表达式生成默认值。
//输出：Default Value
System.out.println(empty.orElseGet(() -& &Default Value&));
//输出：OptionalTest
System.out.println(myValue.orElseGet(() -& &Default Value&));
8）&orElseThrow(Supplier&? extends X& exceptionSupplier)
如果有值则将其返回，否则抛出supplier接口创建的异常。
在orElseGet()方法中，我们传入一个Supplier接口。然而，在orElseThrow中我们可以传入一个lambda表达式或方法，如果值不存在就抛出异常。
//orElseThrow与orElse方法类似。与返回默认值不同，
//orElseThrow会抛出lambda表达式或方法生成的异常
empty.orElseThrow(ValueAbsentException::new);
} catch (Throwable ex) {
//输出: No value present in the Optional instance
System.out.println(ex.getMessage());
class ValueAbsentException extends Throwable {
public ValueAbsentException() {
public ValueAbsentException(String msg) {
super(msg);
public String getMessage() {
return &No value present in the Optional instance&;
9）&map(Function&? super T,? extends U& mapper)
如果有值，则对其执行调用mapping函数得到返回值。如果返回值不为null，则创建包含mapping返回值的Optional作为map方法返回值，否则返回空Optional。
map方法用来对Optional实例的值执行一系列操作。通过一组实现了Function接口的lambda表达式传入操作。
//map方法执行传入的lambda表达式参数对Optional实例的值进行修改。
//为Lambda表达式的返回值创建新的Optional实例作为map方法的返回值。
Optional&String& upperName = myValue.map((value) -& value.toUpperCase());
System.out.println(upperName.orElse(&No value found&));
10）&flatMap(Function&? super T,Optional&U&& mapper)
如果有值，为其执行mapping函数返回Optional类型返回值，否则返回空Optional。flatMap与map（Funtion）方法类似，区别在于flatMap中的mapper返回值必须是Optional。调用结束时，flatMap不会对结果用Optional封装。
flatMap方法与map方法类似，区别在于mapping函数的返回值不同。map方法的mapping函数返回值可以是任何类型T，而flatMap方法的mapping函数必须是Optional。
下面参照map函数，使用flatMap重写的示例
//map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。
//但flatMap方法中的lambda表达式返回值必须是Optionl实例。
upperName = myValue.flatMap((value) -& Optional.of(value.toUpperCase()));
System.out.println(upperName.orElse(&No value found&));
11)&filter(Predicate&? super T& predicate)
如果有值并且满足断言条件返回包含该值的Optional，否则返回空Optional。
filter个方法通过传入限定条件对Optional实例的值进行过滤。
对于filter函数我们可以传入实现了Predicate接口的lambda表达式。
//filter方法检查给定的Option值是否满足某些条件。
//如果满足则返回同一个Option实例，否则返回空Optional。
Optional&String& longName = myValue.filter((value) -& value.length() & 6);
System.out.println(longName.orElse(&The name is less than 6 characters&));//输出OptionalTest
//另一个例子是Optional值不满足filter指定的条件。
Optional&String& anotherName = Optional.of(&Test&);
Optional&String& shortName = anotherName.filter((value) -& value.length() & 6);
//输出：name长度不足6字符
System.out.println(shortName.orElse(&The name is less than 6 characters&));
<span style="color:#）&empty()
返回一个空Optional实例。
Optional.&String&empty(); // 返回一个空Optional&String&
Optional有这么多方法，那Optional的初衷是什么？而且Optional也是一个对象，所以它本身也有可能是null，这可如何是好。所以，个人认为，Optional比较适用的地方是作为返回值，这样可以给使用者一个善意的提醒。
4.4 &map 与 flatMap 的区别
map(mapper) 与 flatMap(mapper) 功能上基本是一样的，只是最后的返回值不一样。map(mapper)方法中的mapper可以返回任意类型，但是flatMap(mapper)方法中的mapper只能返回Optional类型。
如果mapper返回结果result的不是null，那么map就会返回一个Optional,但是 flatMap不会对result进行任何包装。
Optional&String&
o.map((value)-&Optional.of(value)) //返回的类型是Optional&Optional&String&&
o.flatMap((value)-&Optional.of(value)) //返回的类型是Optional&String&
4.5&Optional应用示例：
Note：测试的时候最好是新建一个java项目（或者直接用eclipse测试），因为Android项目目前不完全支持java8的新特性，需要配置很多东西，也一样容易出现各种问题。
import java.util.NoSuchElementE
import java.util.O
public class OptionalTest {
public static void main(String[] args) {
// 创建Optional
String mayBeNull =
Optional&String& opt1 = Optional.of(& Hello! &);
Optional&String& opt2 = Optional.ofNullable(mayBeNull);
Optional&String& opt3 = Optional.empty();
opt1.ifPresent(System.out::println); // & Hello! &
opt2.ifPresent(System.out::println);
opt3.ifPresent(System.out::println);
//方法测试示例
ofNullableTest();
isPresentTest();
ifPresentTest();
orElseTest();
orElseGetTest();
mapTest();
flatMapTest();
filterTest();
* of后面接给optional设置的值 但是不能为空 如果为空会报空指针异常
public static void ofTest() {
Optional&String& optional = Optional.of(&123&);
System.out.println(optional.get());
optional = Optional.of(null);
System.out.println(&null值--&+optional.get());
//get方法是获取optional的值 类型取决于声明的时候
} catch (NullPointerException e) {
System.out.println(&空指针异常&);
* ofNullable 和of类似 但是ofNullable可以设置null值
如果是Null值得话取值会报NoSuchElementException 异常
public static void ofNullableTest() {
Optional&String& optional = Optional.ofNullable(&123&);
System.out.println(optional.get());
optional = Optional.ofNullable(null);
System.out.println(&null值---&+optional.get());
} catch (NoSuchElementException e) {
System.out.println(&NoSuchElementException 异常&);
* ifPresent用来判断optional中有没有值存在 如果有则为真
public static void isPresentTest() {
Optional&String& optional = Optional.ofNullable(null);
if (optional.isPresent()) {
System.out.println(optional.get());
System.out.println(&值为空&);
* ifPresent和isPresent类似 只不过它支持λ表达式
public static void ifPresentTest() {
Optional&String& optional = Optional.ofNullable(&123&);
optional.ifPresent(var -& {
System.out.println(var);
* orElse方法，如果值为空的话会用参数中的值去替换 即设置默认值
public static void orElseTest() {
Optional&String& optional = Optional.ofNullable(&123&);
System.out.println(optional.orElse(&有没有&));
optional = Optional.ofNullable(null);
System.out.println(optional.orElse(&有没有000&));
* orElseGet方法 和orElse类似 不过此方法接受Supplier接口的实现用来生成默认值
public static void orElseGetTest() {
Optional&String& optional = Optional.ofNullable(&123&);
System.out.println(optional.orElseGet(() -& &123456&));
optional = Optional.ofNullable(null);
System.out.println(optional.orElseGet(() -& &1234567&));
如果有值则会对值进行mapping中的处理 处理结果存在则创建并返回Optional类型的结果 否则返回空
public static void mapTest() {
Optional&String& optional = Optional.ofNullable(&abc&);
System.out.println(optional.map(var -& var.toUpperCase()).get());
* flatMap和map类似 只不过mapping中必须返回Option类型的数据
public static void flatMapTest() {
Optional&String& optional = Optional.ofNullable(&abc&);
System.out.println(optional.flatMap(var -& Optional.of(var.toUpperCase())).get());
* filter对optional进行过滤,mapping中为过滤的条件
如果不满足条件 返回一个为空的Optional
public static void filterTest() {
Optional&String& optional = Optional.ofNullable(&一二三四五六七八&);
System.out.println(optional.filter(var -& var.length() & 6).get());
System.out.println(optional.filter(var -& var.length() & 6).get());
} catch (NoSuchElementException e) {
System.out.println(&optional的值为空&);
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：142281次
积分：2188
积分：2188
排名：第18971名
原创：74篇
评论：61条
(1)(3)(2)(3)(6)(2)(1)(1)(7)(5)(2)(1)(4)(3)(4)(4)(2)(1)(2)(2)(3)(1)(3)(2)(1)(4)(6)(1)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'
