Optional的使用

最新推荐文章于 2023-05-29 14:37:25 发布
最新推荐文章于 2023-05-29 14:37:25 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： 后端开发 # Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qjt19950610/article/details/125819588
版权

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，里面还有很多好用的方法和操作，我们就不展开了。

几里路遥
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Optional 使用方法详解
10-18
Optional 使用方法详解
Optional 详细用法
qq_19891197的博客
11-19 9054
Optional 详细用法
Optional使用教程
weixin_46058921的博客
09-14 3806
Java 8 之 Optional 使用
Optional的详细使用
qq_48581332的博客
05-18 705
文章目录一、使用1.创建对象2.安全消费3.安全获取值4.过滤5.判断 一、使用 1.创建对象 1.1 Optional类似是包装类，可以把具体的数据封装在其中，然后使用里面封装好的方法可以有效防止空指针 一般通过Optional类中的ofNullable方法来把数据封装到Optional类 public class Test03 { public static void main(String[] args) { Author author = author();
聊一聊Java8 Optional，让你的代码更加优雅
m0_56069948的博客
04-01 574
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 码农在囧途 随着时间的推移，曾经我们觉得重要的东西，可能在今天看来是如此的浅薄和无知，同理，今天我们放不下，想不开，觉得重要的东西，多年后我们可能也会觉得也就那样，所以，今天的的所有烦恼，忧愁，想不开，其实我们都没必要过于在意，因为有些东西随着时间的冲刷，也就那样了。 前言
Optional类详解及使用方法示例
最新发布
Ascend1977的博客
05-29 4049
Optional类是java8中引入的一个非常有用的类，它可以用来解决空指针异常带来的不便。这个类可以将对象包装为一个Optional对象，如果该对象为空，则可以使用一些默认值或者执行一些默认操作。Optional 是 Java 实现函数式编程的强劲一步，并且帮助在范式中实现。Java8的Optional类提供了丰富的 API 方法，这里按照其功能分类介绍。
实用的Optional使用技巧
三翼鸟数字化平台的技术实践分享
02-24 1191
不管是Java新人还是Java高工，在开发过程中都会碰到需要判断Null值以防止空指针的情况，以往的方式要么是抛异常，要么是if{}else{}，这种方式往往会造成代码的阅读性和维护性变差。这篇文章将围绕在Java8中推出的Optional，来讨论如何优雅的解决判空问题。
使用Java8中Optional机制的正确姿势
08-28
我们知道 Java 8 增加了一些很有用的 API, 其中一个就是 Optional，下面这篇文章主要给大家介绍了关于如何正确使用Java8中Optional机制的相关资料，文中通过示例代码介绍的非常详细，需要的朋友可以参考借鉴，下面来...
使用Optional解决空指针问题共2页.pdf.zip
11-22
使用Optional解决空指针问题共2页.pdf.zip
android_optional
04-27
android_optional 我在使用Java时就知道Optional的存在，但是我无法在Android上使用它，所以我将其制成。用法与标准编写的用法相同示例代码是Kotlin，但是如果您使用Kotlin编写，请使用Kotlin标准Optional。
使用Java读写本地文件（使用流方法）。
iron的博客
01-01 1929
import java.io.File;  import java.io.IOException; import java.io.FileOutputStream; import java.io.FileInputStream; import java.io.FileNotFoundException; public class StreamTest {
GirdLayout布局的举例
iron的博客
10-25 785
package 窗口; import javax.swing.*; import java.awt.*; public class example095 { public static void main(String[] args) { // TODO Auto-generated method stub new WinGrid(); } } class Wi
pgsql常用sql和函数
iron的博客
03-24 740
pgsql常用函数，时间函数
求子串
iron的博客
02-01 657
package day1; public class Teststring { public static void main(String[] args){ String s="Helloworld"; s=s.substring(5, 10); System.out.println(s); } } 注释：求world子串，注意是（5，10），而不是（5，9
从封装性，继承性，多态性来认识面向对象
iron的博客
10-07 548
一，类的封装是指在定义一个类时，将类中的属性私有化，即使用private关键字来修饰，私有属性只能在它所在类中被访问。一般需要获取属性值的方法和设置属性值的方法来让外界访问私有属性。 package encapsulation; class Student { private String name; private int age; // 将类的属性私有化 // 下面是公有的方法 ...
Java的中optional使用方法
05-26
使用Optional可以更好地处理null值的情况，避免出现NullPointerException异常。 以下是使用Optional的一些方法： 1. 创建Optional对象： ``` Optional<String> optional = Optional.of("Hello World"); ``` 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值