OPtional类的使用

概述

到目前为止,臭名昭著的空指针异常是导致Java应用程序失败的最常见原因。以前,为了解决空指针异常,Google公司著名的Guava项目引入了Optional类,Guava通过使用检查空值的方式来防止代码污染,它鼓励程序员写更干净的代码。受到Google Guava的启发,Optional类已经成为Java 8类库的一部分。

Optional实际上是个容器:它可以保存类型T的值,或者仅仅保存null。Optional提供很多有用的方法,这样我们就不用显式进行空值检测。

Optional类的Javadoc描述如下:这是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true,调用get()方法会返回该对象。

Optional 类(java.util.Optional) 是一个容器类,代表一个值存在或不存在,原来用 null 表示一个值不存在,现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。

Optional类的常用方法:

Optional.empty() : 创建一个空的 Optional 实例

Optional.of(T t) : 创建一个 Optional 实例

Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例

isPresent() : 判断是否包含值

T get(): 如果调用对象包含值,返回该值,否则抛异常

orElse(T t) : 如果调用对象包含值,返回该值,否则返回t

orElseGet(Supplier s) :如果调用对象包含值,返回该值,否则返回 s 获取的值

map(Function f): 如果有值对其处理,并返回处理后的Optional,否则返回 Optional.empty()

flatMap(Function mapper):与 map 类似,要求返回值必须是Optional

代码演示

/**
*
*/
package com.xnn.Optional; import java.util.Optional; import org.junit.Test; import com.xnn.lambda.Person; /**
* 类(接口)描述: Optional.of(T t) : 创建一个 Optional 实例 Optional.empty()
* :创建一个空的Optional实例 Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
* isPresent() : 判断是否包含值 T get(): 如果调用对象包含值,返回该值,否则抛异常 orElse(T t) :
* 如果调用对象包含值,返回该值,否则返回t orElseGet(Supplier s) :如果调用对象包含值,返回该值,否则返回 s 获取的值
* map(Function f): 如果有值对其处理,并返回处理后的Optional,否则返回 Optional.empty()
* flatMap(Function mapper):与 map 类似,要求返回值必须是Optional
*
* @author xnn 2018年10月25日下午2:12:54
*/
public class TestOptional {
@Test
public void test() {
// Optional.of(T t) : 创建一个 Optional 实例,参数也可为null 表示把null封装进了OPtional容器
Optional<Person> optional = Optional.of(new Person("李四", 59, 6666.66)); // T get(): 如果调用对象包含值,返回该值,否则抛异常
Person person = optional.get();
System.out.println("person" + person);
System.out.println("===========");
// 参数设为null的情况 会报空指针异常
Optional<Person> optiona2 = Optional.of(null);
System.out.println(optiona2.get()); }
@Test
public void test1() {
// Optional.empty() :创建一个空的Optional实例
Optional<Person> empty = Optional.empty();
// 因为Optional容器里面是空的 所以报了个NoSuchElementException,这样容易定位空指针
// 和Optional.of(null)还不太一样。Optional.of(null).get()就报了个空指针
System.out.println("empty.get():" + empty.get());
}
@Test
public void test2() {
// Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
Optional<Object> nullable = Optional.ofNullable(null);
// T为null创建空实例,融合了of()方法的缺陷
System.out.println("nullable:" + nullable);
}
@Test
public void test3() {
Optional<Object> nullable = Optional.ofNullable(null); // isPresent() : 判断是否包含值 nullable为空 所以返回false
boolean present = nullable.isPresent();
System.out.println("present:" + present);
}
@Test
public void test4() {
Optional<Person> optional = Optional.of(new Person("李四", 59, 6666.66));
// orElse(T t) : 如果调用对象包含值,返回该值,否则返回t
// 就是先看optional这个容器里面有值与否 若有,则直接返回 若没有 返回T
Object orElse = optional.orElse(new Person());
System.out.println(orElse); }
@Test
public void test5() {
// orElseGet(Supplier s) :如果调用对象(调用者是Optional类)包含值,返回该值,否则返回 s 获取的值
// 和上面不同的是这里的参数需要我们提供一个Supplier类型的函数式接口
// ,这样我们就可以在Lambda表达式体中写自己的逻辑没最后返回个T
Optional<Person> optional = Optional.of(new Person("李四", 59, 6666.66));
Person orElseGet = optional.orElseGet(() -> new Person());
// 因为optional包含的对象是有值的。所以返回new Person("李四", 59, 6666.66)
System.out.println("orElseGet:" + orElseGet);
Optional<Object> nullable = Optional.ofNullable(null);
// 这个nulllable时空的
Object elseGet = nullable.orElseGet(() -> new Person());
// 所以返回参数(函数式接口与返回的值,即无参构造器返回的是默认值)
System.out.println("elseGet:" + elseGet);
}
@Test
public void test6() {
// map(Function f): 如果有值对其处理,并返回处理后的Optional,否则返回 Optional.empty()
Optional<Person> optional = Optional.of(new Person("李四", 59, 6666.66));
Optional<String> map = optional.map(Person::getName);
System.out.println("map:"+map);
}
@Test
public void test7() {
// flatMap(Function mapper):与 map 类似,
Optional<Person> optional = Optional.of(new Person("李四", 59, 6666.66));
//要求返回值必须是Optional 所以在参数那里 Lambda表达式的返回值用Optional包装了一层
Optional<String> flatMap = optional.flatMap((e) -> Optional.of(e.getName()));
System.out.println("flatMap"+flatMap);
}
}

运行结果

nullable:Optional.empty
present:false
Person [name=李四, age=59, salary=6666.66, status=null]
orElseGet:Person [name=李四, age=59, salary=6666.66, status=null]
elseGet:Person [name=null, age=0, salary=0.0, status=null]
map:Optional[李四]
flatMapOptional[李四]

一个小应用场景

父亲类:


package com.xnn.Optional; /**
* 类(接口)描述:
* @author xnn
* 2018年10月25日下午3:21:31
*/
public class Father {
private Son son; public Father() {
super();
}
public Father(Son son) {
super();
this.son = son;
}
public Son getSon() {
return son;
}
public void setSon(Son son) {
this.son = son;
} @Override
public String toString() {
return "Father [son=" + son + "]";
} }

son 类


package com.xnn.Optional; /**
* 类(接口)描述:
* @author xnn
* 2018年10月25日下午3:21:51
*/
public class Son {
private String name; public Son() {
super();
}
public Son(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Son [name=" + name + "]";
} }

现做一个小功能 传进来一个Father对象 返回他的儿子的名字 为了确保不出现空指针异常,我们通常的做法是

1、判断传进来的Father是否为空,若为空 什么也不做 若不为空 获取其son属性

2、判断son是否为空 若为空 返回null 若不为空 调用son的getName()方法进行返回

若属性太多,或者是包装的层数过多,则会导致很深的if嵌套 造成代码可读性变差

因此 我们改变Father类 把son属性用Optional类包装

/**
*
*/
package com.xnn.Optional; import java.util.Optional; /**
* 类(接口)描述:
* @author xnn
* 2018年10月25日下午3:30:00
*/
public class Father2 { private Optional<Son> son =
//保证OPtional类不为空
Optional.empty();
public Father2() {
super();
}
public Father2(Optional<Son> son) {
super();
this.son = son;
} public Optional<Son> getSon() {
return son;
}
public void setSon(Optional<Son> son) {
this.son = son;
} @Override
public String toString() {
return "Father2 [son=" + son + "]";
} }

测试类

@Test
public void test8() {
Father father =new Father();
//报了个空指针
//getSonName(father);
//可以用if判断语句嵌套判断 避免空指针 但若嵌套太深 代码可读性也会变差
Optional<Father2> optional = Optional.ofNullable(new Father2(Optional.ofNullable(new Son("小明"))));
System.out.println(getSonName1(optional));;
}
//需求:获取父亲的儿子的名字
public String getSonName(Father father) {
return father.getSon().getName();
}
//传进来的father也有可能为空 所以用Optional包装
public String getSonName1(Optional<Father2> optional) {
//若传进来的对象为空没给一个默认值,保证了传进来的对象不会为空
return optional.orElse(new Father2())
.getSon()
//这个人可能还没有儿子,若没有 默认为孙悟空 避免了getName()方法的空指针
.orElse(new Son("孙悟空"))
.getName();
}

结果

小明

Java8新特性——Optional类的使用(有效的避免空指针异常)的更多相关文章

  1. Java8 新特性 Optional 类

    Optional 类的简介   Optional类的是来自谷歌Guava的启发,然后就加入到Java8新特性中去了.Optional类主要就是为子决解价值亿万的错误,空指针异常.   Optional ...

  2. JDK1.8新特性——Optional类

    JDK1.8新特性——Optional类 摘要:本文主要学习了JDK1.8新增加的Optional类. 部分内容来自以下博客: https://www.cnblogs.com/1ning/p/9140 ...

  3. Java8新特性——Optional

    前言 在开发中,我们常常需要对一个引用进行判空以防止空指针异常的出现.Java8引入了Optional类,为的就是优雅地处理判空等问题.现在也有很多类库在使用Optional封装返回值,比如Sprin ...

  4. JAVA8新特性Optional,非空判断

    Optional java 的 NPE(Null Pointer Exception)所谓的空指针异常搞的头昏脑涨, 有大佬说过 "防止 NPE,是程序员的基本修养." 但是修养归 ...

  5. Java8新特性--Optional

    Java 8引入了一个新的Optional类.Optional类的Javadoc描述如下: 这是一个可以为null的容器对象.如果值存在则isPresent()方法会返回true,调用get()方法会 ...

  6. java8 新特性 -Optional的常见用法

    1. Optional 一. 简介 Opitonal是java8引入的一个新类,目的是为了解决空指针异常问题.本质上,这是一个包含有可选值的包装类,这意味着 Optional 类既可以含有对象也可以为 ...

  7. Java8新特性Optional、接口中的默认方法与静态方法

    Optional Optional 类(java.util.Optional) 是一个容器类,代表一个值存在或不存在,原来用 null 表示一个值不存在,现在 Optional 可以更好的表达这个概念 ...

  8. Java8新特性 - Optional容器类

    Optional 类(java.util.Optional) 是一个容器类,代表一个值存在或不存在,原来用null 表示一个值不存在,现在Optional 可以更好的表达这个概念.并且可以避免空指针异 ...

  9. java8 新特性 Optional容器类

    public class Godness { private String name; public Godness() { } public Godness(String name) { this. ...

随机推荐

  1. MySQL(10)---自定义函数

    MySQL(10)---自定义函数 之前讲过存储过程,存储过程和自定义函数还是非常相似的,其它的可以认为和存储过程是一样的,比如含义,优点都可以按存储过程的优点来理解. 存储过程相关博客: 1.MyS ...

  2. wpf dual monitor

    <Window x:Class="DualMonitors.Views.WinLeft" xmlns="http://schemas.microsoft.com/w ...

  3. CSS3 过渡---transition

    过渡(transition)是CSS3中具有颠覆性的特征之一,我们可以在不使用 Flash 动画或 JavaScript 的情况下,当元素从一种样式变换为另一种样式时为元素添加效果. 过渡动画: 是从 ...

  4. docker部署gitlab-ce

    简介 环境准备 centos7 docker 1.13.1 gitlab-ce 安装步骤 1.首先需要从docker镜像仓库当中获取gitlab-ce的最新镜像文件,由于我本机已经获取了该镜像,所以在 ...

  5. 有趣的bug——Java静态变量的循环依赖

    背景 是的,标题没有错误,不是Spring Bean的循环依赖,而是静态变量之间的循环依赖. 近期的项目均是简单的Maven项目,通过K8S部署在阿里云上,其配置文件读取规则如下所示: (1) 优先读 ...

  6. Maven报错Please ensure you are using JDK 1.4 or above and not a JRE

    在部署Jenkins项目时,用Jenkins调用服务器上脚本时,脚本在服务器上执行没有任何问题,但是在Jenkins上调用时就报错,提示mvn应该使用全路径执行,当加入jdk,jre,maven环境变 ...

  7. openresty安装笔记

    目录 安装步骤: openresty安装在ubuntu下的安装 参考 安装OpenResty(Nginx+Lua)开发环境 安装步骤: # 创建目录/usr/servers,以后我们把所有软件安装在此 ...

  8. python简单面试题

    在这个即将进入金9银10的跳槽季节的时候,肯定需要一波面试题了,安静总结了一些经常遇到的python面试题,让我们一起撸起来. python面试题 1.求出1-100之间的和 # coidng:utf ...

  9. Ambassador中,启用不同的Load balancing算法

    默认就是轮循,如果要其它hash或是最少请求,那就需要作更多的设置了. https://www.getambassador.io/reference/core/load-balancer/#sourc ...

  10. 【转】Restful架构详解

    1. 什么是REST REST全称是Representational State Transfer,中文意思是表述(编者注:通常译为表征)性状态转移. 它首次出现在2000年Roy Fielding的 ...