聊一聊Java8 Optional,让你的代码更加优雅

java

码农在囧途

随着时间的推移,曾经我们觉得重要的东西,可能在今天看来是如此的浅薄和无知,同理,今天我们放不下,想不开,觉得重要的东西,多年后我们可能也会觉得也就那样,所以,今天的的所有烦恼,忧愁,想不开,其实我们都没必要过于在意,因为有些东西随着时间的冲刷,也就那样了。

前言

Java8提供了Optional接口,Optional接口能够是我们的代码变得更加的优雅,可读性更高,同时能够很好的避免空指针,因为空指针是一个很让人头疼的问题,特别对于调用第三方接口,如果不知道对象的规约的时候,我们在取值的时候无法直到那些值能为空,那些不能为空,所以容易出现空指针,如果我们谨慎一点,可能会对每一个值进行判空处理,但是将会充斥着大量的if语句,甚是不雅观。

下面我们介绍一下Optional类的方法

empty()

返回一个空的Optional对象 Optional.empty

of(T value)

参数传入一个对象,返回一个Option对象,value不能为空,如果为null,将抛出空指针异常

 /**

  * @author 刘牌

  * @date 2022-03-2921:52

  */

 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对象

 /**

  * @author 刘牌

  * @date 2022-03-2921:52

  */

 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) 符合规则,返回Optional对象

 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

 /**

  * @author 刘牌

  * @date 2022-03-3023:22

  */

 @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

 /**

  * @author 刘牌

  * @date 2022-03-3023:16

  */

 @Data

 @Accessors(chain = true)

 public class UserInfo {

     private String name;

     private Integer age;

     private Family family;

     private Education education;

 }

用户VO,返回前端的视图对象

 /**

  * @author 刘牌

  * @date 2022-03-2922:02

  */

 @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。

 /**

  * @author 刘牌

  * @date 2022-03-2921:52

  */

 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("小四哥")

                .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(userInfo.getFamily().getFatherName()).setMother(userInfo.getFamily().getMotherName());

    });

     Optional.ofNullable(userInfoI.getEducation()).ifPresent(education -> {

         user.setEdu(userInfo.getEducation().getEducation())

                .setSchool(userInfo.getEducation().getSchoolName())

                .setAdmissionDate(userInfo.getEducation().getAdmissionTime())

                .setGraduationDate(userInfo.getEducation().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,里面还有很多好用的方法和操作,我们就不展开了。

今天的分享就到这里,感谢你的观看,我们下期见!

以上是 聊一聊Java8 Optional,让你的代码更加优雅 的全部内容, 来源链接: utcz.com/z/395062.html

回到顶部