1. 前言
相信不少小伙伴已经被java的NPE(Null Pointer Exception)所谓的空指针异常搞的头昏脑涨, 有大佬说过“防止 NPE,是程序员的基本修养。”但是修养归修养,也是我们程序员最头疼的问题之一,那么我们今天就要尽可能的利用Java8的新特性 Optional来尽量简化代码同时高效处理NPE(Null Pointer Exception 空指针异常)
2. 认识Optional并使用
简单来说,Opitonal类就是Java提供的为了解决大家平时判断对象是否为空用 会用 null!=obj 这样的方式存在的判断,从而令人头疼导致NPE(Null Pointer Exception 空指针异常),同时Optional的存在可以让代码更加简单,可读性跟高,代码写起来更高效.
//常规判断: //对象 人 //属性有 name,age Person person=new Person(); if (null==person){ return "person为null"; } return person; //使用Optional: //对象 人 //属性有 name,age Person person=new Person(); return Optional.ofNullable(person).orElse("person为null");
测试展示类Person代码(如果有朋友不明白可以看一下这个):
public class Person { private String name; private Integer age; public Person(String name, Integer age) { this.name = name; this.age = age; } public Person() { } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } }
下面,我们就高效的学习一下神奇的Optional类!
optional方法详解
empty()
返回一个空的Optional对象 Optional.empty
of(T value)
参数传入一个对象,返回一个Option对象,value不能为空,如果为null,将抛出空指针异常
public class OptionalTest {
public static void main(String[] args) {
User user = null;
Optional<User> optional = Optional.of(user);
System.out.println(user);
}
}
复制代码
ofNullable(T value)
参数传入一个对象,可以为空,如果为空,将返回一个空的Optional对象,就等于Optional.empty(),输出的值为Optional.empty
,如果不为空,返回一个不为空的Optional对象
public class OptionalTest {
public static void main(String[] args) {
User user = null;
Optional<User> optional = Optional.ofNullable(user);
System.out.println(optional);
}
}
复制代码
get()
获取Optional中的值,这个值也就是我们的值,Optional相当于就是一个外壳。
public class OptionalTest {
public static void main(String[] args) {
User user = null;
Optional<User> optional = Optional.ofNullable(user);
User user1 = optional.get();
}
}
复制代码
isPresent()
判断Optional对象中是否有值,如果有值,返回true,没值返回false。
true
public class OptionalTest {
public static void main(String[] args) {
User user = new User();
Optional<User> optional = Optional.ofNullable(user);
System.out.println(optional.isPresent());
}
}
复制代码
false
public class OptionalTest {
public static void main(String[] args) {
User user = null;
Optional<User> optional = Optional.ofNullable(user);
System.out.println(optional.isPresent());
}
}
复制代码
ifPresent(Consumer<? super T> consumer)
ifPresent参数是一个函数式接口,无返回值,会将Optional中的值作为参数传递到ifPresent()中
public class OptionalTest {
public static void main(String[] args) {
User user = new User();
Optional<User> optional = Optional.ofNullable(user);
optional.ifPresent(s -> System.out.println(s));
}
}
复制代码
filter(Predicate<? super T> predicate)
是一个Predicate函数接口,会将Optional中的值作为参数传入,如果符合规则,那么返回一个Optional对象,否则返回一个空的Optional 对象(Optional.empty)
public class OptionalTest {
public static void main(String[] args) {
User user = new User();
user.setUsername("我是小四哥");
Optional<User> optional = Optional.ofNullable(user);
Optional<User> optional1 = optional.filter(v -> v.getUsername().equals("我是小四哥"));
System.out.println(optional1);
}
}
复制代码
不符合规则,返回空Optional(Optional.empty
)
public class OptionalTest {
public static void main(String[] args) {
User user = new User();
user.setUsername("我是小四哥");
Optional<User> optional = Optional.ofNullable(user);
Optional<User> optional1 = optional.filter(v -> v.getUsername().equals("我不是小四哥"));
System.out.println(optional1);
}
}
复制代码
map(Function<? super T, ? extends U> mapper)
参数是一个Function函数式接口,会将Optional中的值作为参数传递到map中,如果传入的值为空,则返回一空的Optional对象,相当于Optional.empty(), 如果不为空,我们可以返回一个可以描述描述结果的返回值(Optional中的值,这个值可以重新赋值),如下面的返回一个tempUser
Optional中的值为空
public class OptionalTest {
public static void main(String[] args) {
User user = null;
Optional<String> optional = Optional.ofNullable(user).map(OptionalTest::getMap);
System.out.println(optional); //Optional.empty
}
public static String getMap(User user){
return user.getUsername();
}
}
复制代码
Optional中的值不为空
public class OptionalTest {
public static void main(String[] args) {
User user = new User();
user.setUsername("我是小四哥");
user.setAge(20);
Optional<String> optional = Optional.ofNullable(user).map(OptionalTest::getMap);
System.out.println(optional); // Optional[我是小四哥]
}
public static String getMap(User user){
return user.getUsername();
}
}
复制代码
flatMap(Function<? super T, Optional> mapper)
如果Optional中值存在,那么返回一个基于Optional的值(如Optional),如果Optional中的值不存在,则返回一空的Optional对象,相当于Optional.empty(),与map不同, map返回的是一个值,而flatMap返回一个基于Optional的值
public class OptionalTest {
public static void main(String[] args) {
User user = new User();
user.setUsername("我是小四哥");
user.setAge(20);
Optional<String> optional = Optional.ofNullable(user).flatMap(OptionalTest::getFlatMap);
System.out.println(optional);
}
public static Optional<String> getFlatMap(User user){
return Optional.ofNullable(user).map(User::getUsername);
}
}
复制代码
orElse(T other)
如果Optional中的值不为空,则返回Optional中的值,如果为空,则返回other值,
String value = "2";
String orElse = Optional.ofNullable(value).orElse("1");
System.out.println(orElse); //2
String value = null;
String orElse = Optional.ofNullable(value).orElse("1");
System.out.println(orElse); //1
复制代码
orElseGet(Supplier<? extends T> other)
如果Optional中存在值,则返回值,否则返回other调用的结果
Optional中存在值
public class OptionalTest {
public static void main(String[] args) {
String value = null;
String orElse = Optional.ofNullable(value).orElseGet(OptionalTest::get);
System.out.println(orElse); // 123
}
public static String get(){
return "123";
}
}
复制代码
Optional中不存在值
public class OptionalTest {
public static void main(String[] args) {
String value = "2";
String orElse = Optional.ofNullable(value).orElseGet(OptionalTest::get);
System.out.println(orElse); // 2
}
public static String get(){
return "123";
}
}
复制代码
orElseThrow(Supplier<? extends X> exceptionSupplier)
如果Optional中的值存在,则返回值,值不存在,则抛出异常函数Supplier中的异常
public class OptionalTest {
public static void main(String[] args) {
String value = null;
String orElse = Optional.ofNullable(value).orElseThrow(() -> new RuntimeException("不存在值"));
System.out.println(orElse);
}
}
复制代码
输出
Exception in thread "main" java.lang.RuntimeException: 不存在值
at com.steak.javase.optional.OptionalTest.lambda$main$0(OptionalTest.java:14)
at java.util.Optional.orElseThrow(Optional.java:290)
at com.steak.javase.optional.OptionalTest.main(OptionalTest.java:13)
复制代码
实战,去除if判断
我们将一个从远程接口获取了一个用户的信息,包含家庭信息,学历信息,个人信息,然后封装成一个VO,再返回前端进行展示。
家庭实体Family
@Data
@Accessors(chain = true)
public class Family {
private String fatherName;
private String motherName;
}
复制代码
学历实体Education
@Data
@Accessors(chain = true)
public class Education {
private String education;
private String schoolName;
private Date admissionTime;
private Date graduationTime;
}
复制代码
用户信息实体UserInfo
@Data
@Accessors(chain = true)
public class UserInfo {
private String name;
private Integer age;
private Family family;
private Education education;
}
复制代码
用户VO,返回前端的视图对象
@Data
@Accessors(chain = true)
public class UserVO {
private String username;
private Integer userAge;
private String edu;
private String school;
private Date admissionDate;
private Date graduationDate;
private String mother;
private String father;
}
复制代码
如果没有做判空处理,如下代码,因为getUser()接口中并没有为family属性设值,所以为null,那么main方法中对其进行赋值的时候,肯定会抛出空指针异常NullPointerException。
public class OptionalTest {
public static void main(String[] args) {
UserInfo userInfo = getUser();
UserVO user = new UserVO();
user.setUsername(userInfo.getName()).setUserAge(userInfo.getAge())
.setEdu(userInfo.getEducation().getEducation())
.setSchool(userInfo.getEducation().getSchoolName())
.setAdmissionDate(userInfo.getEducation().getAdmissionTime())
.setGraduationDate(userInfo.getEducation().getGraduationTime())
.setFather(userInfo.getFamily().getFatherName())
.setMother(userInfo.getFamily().getMotherName());
System.out.println(user);
}
public static UserInfo getUser(){
Family family = new Family().setFatherName("father")
.setMotherName("mother");
Education education = new Education().setEducation("本科")
.setSchoolName("家里蹲大学")
.setAdmissionTime(new Date())
.setGraduationTime(new Date());
return new UserInfo()
.setName("66哥")
.setAge(24)
.setEducation(education);
}
}
复制代码
所以我们需要做判空校验,那么大多数人肯定会使用如下方式进行判断,先判断userInfo是否null,再接着判断education属性和family属性是否为null,为null不赋值,这样就能避免空指针,这是绝大多数人都会这样做的,这样做确实是没错的,但是我们发现代码中存在很多if判空操作,看起来其实不怎么好看。
if (null != userInfo){
user.setUsername(userInfo.getName()).setUserAge(userInfo.getAge());
if (null != userInfo.getEducation()){
user.setEdu(userInfo.getEducation().getEducation())
.setSchool(userInfo.getEducation().getSchoolName())
.setAdmissionDate(userInfo.getEducation().getAdmissionTime())
.setGraduationDate(userInfo.getEducation().getGraduationTime());
}
if (null != userInfo.getFamily()){
user.setFather(userInfo.getFamily().getFatherName())
.setMother(userInfo.getFamily().getMotherName());
}
}
复制代码
使用Optional接口进行改造,额~~~,这好像也没改造出啥东西来啊,没错,确实没改造出什么新花样来,除了增加一些函数操作,基本没啥改变,但是我们能直观的看出,代码比上面的会好维护一点,因为大家都比较烦if,那么,除了好看一点,好维护一点,还有啥好处呢,我觉得如果你对一些返回的结果不能很确定其返回值值的情况下,那么使用Optional来避免空指针是一个很好的办法,因为在开发中可能并不会想得那么周到,可能某处因为疏忽或者没考虑到,忘记加了if判空,那么后续可能会导致空指针,如果使用Optional的话,那么这个问题能够得到避免。
Optional.ofNullable(userInfo).ifPresent(userInfoI -> {
user.setUsername(userInfoI.getName()).setUserAge(userInfoI.getAge());
Optional.ofNullable(userInfoI.getFamily()).ifPresent(family -> {
user.setFather(family.getFatherName()).setMother(family.getMotherName());
});
Optional.ofNullable(userInfoI.getEducation()).ifPresent(education -> {
user.setEdu(education.getEducation())
.setSchool(education.getSchoolName())
.setAdmissionDate(education.getAdmissionTime())
.setGraduationDate(education.getGraduationTime());
});
});
复制代码
获取用户毕业时间,去除if多重判断
不使用Optional,使用if判断
public static Date getGraduationTime(UserInfo userInfo){
if (null != userInfo){
if (null != userInfo.getEducation()){
return userInfo.getEducation().getGraduationTime();
}
}
return null;
}
复制代码
使用Optional
public static Date getGraduationTime(UserInfo userInfo){
return Optional.ofNullable(userInfo)
.map(UserInfo::getEducation)
.map(Education::getGraduationTime)
.orElse(null);
}
复制代码
关于Optional,里面还有很多好用的方法和操作,我们就不展开了。