JDK8新特性：Optional 类的使用

Optional类的使用

      JDK8以前，编写代码，通常会出现 NullPointerException (空指针异常)，通常情况下我们都是通过 if ... else... 来对对象进行为空判断，然后再进行逻辑处理，代码写起来也比较冗余。

      JDK8新增了Optional类，使用该类可以避免我们对空指针的检查，使代码看起来比较优雅。

1.Optional类介绍

     JDK8 新增了 Optional 类， Optional 类是一个没有子类的工具类。我们可以把 Optional 类看作是一个容器。这个容器它有两种情况：①要么有值   ②要么为null。如下图所示：

    

2.以前对 null 的处理方式

  1. public class Demo {
  2.  
  3. public static void main(String[] args) {
  4.  
  5. Person person = new Person("Lucy",18,"BeiJing");
  6.  
  7. if(person != null){
  8. System.out.println(person);
  9. }else{
  10. System.out.println("person为空");
  11. }
  12. }
  13. }

3.创建 Optional 类对象的方式

  1. //创建 Optional 类，共有如下 3 种方式：
  2. //1.创建一个 Optional 实例
  3. Optional.of(T t);
  4. //2.创建一个空的 Optional 实例
  5. Optional.empty();
  6. //3.若 t 不为 null，创建 Optional实例，否则创建空实例
  7. Optional.ofNullable(T t);
  1. public class OptionalDemo {
  2.  
  3. public static void main(String[] args) {
  4. //1.1 通过Optional.of() 方法,只能传入一个具体指,不能传入null,传入null报空指针异常
  5. Optional<String> op1 = Optional.of("Lucy");
  6. //Optional<Object> op2 = Optional.of(null);
  7. System.out.println(op1);//Optional[Lucy]
  8. //System.out.println(op2);//java.lang.NullPointerException
  9.  
  10. //1.2 通过Optional.ofNullable()方法(可以传入具体值,也可以传入null,并不会报空指针异常)
  11. Optional<String> op3 = Optional.ofNullable("Lucy");
  12. Optional<Object> op4 = Optional.ofNullable(null);
  13. System.out.println(op3);//Optional[Lucy]
  14. System.out.println(op4);//Optional.empty
  15.  
  16. //1.3 通过 Optional.empty() 方法创建一个空 Optional,存入的是null
  17. Optional<Object> op5 = Optional.empty();
  18. System.out.println(op5);//Optional.empty
  19. }
  20. }

4.Optional 类常用方法

 1.isPresent() 

      判断是否包含值。包含值返回 true，不包含值返回 false

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //1.isPresent():判断是否包含值,包含值返回 true,不包含值返回 false
  4. Optional<String> optional = Optional.of("Mary");
  5. boolean isPresent = optional.isPresent();
  6. System.out.println("是否包含值:" + isPresent);//是否包含值:true
  7.  
  8. Optional<Object> emptyOpt = Optional.empty();
  9. boolean emptyPresent = emptyOpt.isPresent();
  10. System.out.println("是否包含值:" + emptyPresent);//是否包含值:false
  11. }
  12. }

  2.get() 

       如果Optional有值则将其返回，否则抛出 NoSuchElementException: No value present 异常

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //get():如果Optional有值则将其返回,否则抛出 NoSuchElementException: No value present 异常
  4. Optional<String> optional = Optional.of("Mary");
  5. String name = optional.get();
  6. System.out.println("获取值:" + name);//获取值:Mary
  7.  
  8. Optional<Object> emptyOpt = Optional.empty();
  9. Object obj = emptyOpt.get();
  10. System.out.println("获取值:"+obj);//NoSuchElementException: No value present
  11. }
  12. }

  3.orElse()

       如果调用对象包含值，返回该值，否则返回参数字符串str

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //orElse(String str):如果调用对象包含值,返回该值,否则返回参数字符串str
  4. Optional<String> optional = Optional.of("Mary");
  5. String tipMsg = optional.orElse("optional为空显示我");
  6. System.out.println(tipMsg);//Mary
  7.  
  8. Optional<Object> emptyOpt = Optional.empty();
  9. Object emptyMsg = emptyOpt.orElse("optional为空显示我");
  10. System.out.println(emptyMsg);//optional为空显示我
  11. }
  12. }

  4.orElseGet()

       如果调用对象包含值，返回该值。否则返回 s 获取的值

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //orElseGet(Supplier supplier):如果调用对象包含值,返回该值.否则返回 s 获取的值
  4. //同 orElse()类似,只是传参数类型不同,orElse() 为 String类型,orElseGet() 为 lambda
  5. Optional<String> optional = Optional.of("Mary");
  6. String retVal = optional.orElseGet(() -> "aaa");
  7. System.out.println(retVal);//Mary
  8.  
  9. Optional<Object> emptyOpt = Optional.empty();
  10. Object emptyVal = emptyOpt.orElseGet(() -> "aaa");
  11. System.out.println(emptyVal);//aaa
  12. }
  13. }

 5.orElseThrows()

      如果存在该值，返回包含的值，否则抛出由 Supplier 继承的异常

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //orElseThrow(Supplier exceptionSupplier):如果存在该值,返回包含的值,否则抛出由 Supplier 继承的异常
  4. Optional<String> optional = Optional.of("mary");
  5. String optVal = optional.orElseThrow(() -> new NullPointerException("Optional为空"));
  6. System.out.println(optVal);//mary
  7.  
  8. Optional<String> emptyOpt = Optional.empty();
  9. String emptyVal = emptyOpt.orElseThrow(() -> new NullPointerException("Optional为空"));
  10. System.out.println(emptyVal);//Exception in thread "main" java.lang.NullPointerException: Optional为空
  11. }
  12. }

 6.map()

        如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //map(Function f):如果有值对其处理,并返回处理后的Optional,否则返回 Optional.empty()
  4. //与 Stream 流 map()方法类似,可用于类型转换等操作
  5. Person person = new Person("Mary", 18, "BeiJing");
  6. Optional<Person> optPerson = Optional.of(person);
  7. Optional<String> optName = optPerson.map(p -> p.getName());
  8. System.out.println("Name:" + optName.get());//Name:Mary
  9. }
  10. }

7.flatMap()

       如果有值，为其执行 mapping 函数返回 Optional 类型返回值，否则返回空Optional。

       flatMap() 与 map()方法类似，区别在于 mapping 函数的返回值不同。map() 方法的 mapping 函数返回值可以是任何类型T，在 map () 方法返回之前会包装为 Optional。而 flatMap() 方法的 mapping 函数必须是 Optional。调用结束时，flatMap不会对结果用Optional封装。

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. Person person = new Person("Mary", 18, "BeiJing");
  4. Optional<Person> p1 = Optional.ofNullable(person);
  5. //map()
  6. Optional<String> opt1 = p1.map(p -> p.getName());
  7. System.out.println("map方法返回:"+opt1.get());//map方法返回:Mary
  8. //flatMap()
  9. Optional<String> opt2 = p1.flatMap(p -> Optional.of(p.getName()));
  10. System.out.println("flatMap方法返回:"+opt2.get());//flatMap方法返回:Mary
  11. }
  12. }

8.filter()

      filter()方法通过传入限定条件对 Optional 实例的值进行过滤。如果有值并且满足 Predicate判断条件，则返回包含该值的Optional，否则返回空 Optional。

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //filter(Predicate predicate):如果值存在,并且这个值匹配给定的 predicate,返回一个Optional用以描述这个值,否则返回一个空的Optional。
  4. Optional<String> opt1 = Optional.of("Johnson");
  5. String optVal1 = opt1.filter(str -> str.length() > 4).orElseThrow(()->new RuntimeException("The name is less than 4 characters"));
  6. System.out.println(optVal1);//Johnson
  7.  
  8. Optional<String> opt2 = Optional.of("Mary");
  9. String optVal2 = opt2.filter(str -> str.length() > 4).orElse("The name is less than 4 characters");
  10. System.out.println(optVal2);//The name is less than 4 characters
  11. }
  12. }

  9.ifPresent()

       如果值存在则使用该值调用consumer，否则不做任何事情

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //ifPresent(Consumer consumer):如果值存在则使用该值调用consumer,否则不做任何事情。
  4. Optional<String> optional = Optional.of("Mary");
  5. optional.ifPresent((str)-> System.out.println(str.toLowerCase()));//mary
  6.  
  7. Optional<String> emptyOpt = Optional.empty();
  8. emptyOpt.ifPresent(System.out::println);//不返回内容
  9. }
  10. }

  10.ifPresentOrElse()

        JDK9以后提供。如果值存在则使用该值调用consume，否则执行自定义的 Runnalbe 操作

  1. public class OptionalDemo {
  2.  
  3. public static void main(String[] args) {
  4. //ifPresentOrElse(Consumer consumer, Runnable emptyAction):
  5. Optional<String> optional = Optional.of("Mary");
  6. optional.ifPresentOrElse((str)-> System.out.println(str.toLowerCase()),()-> System.out.println("str为空"));//mary
  7.  
  8. Optional<String> emptyOpt = Optional.empty();
  9. emptyOpt.ifPresentOrElse((str)-> System.out.println(str.toLowerCase()),()-> System.out.println("str为空"));//str为空
  10. }
  11. }

  11.equals()

         判断其他对象是否等于Optional

  1. public class OptionalDemo {
  2. public static void main(String[] args) {
  3. //equals(Object obj):判断其他对象是否等于Optional
  4. Optional<String> opt1 = Optional.of("Johnson");
  5. Optional<String> opt2 = Optional.of("Johnson");
  6. boolean flag = opt1.equals(opt2);
  7. System.out.println(flag);//true
  8. }
  9. }

附：JDK8新特性（目录）

       本目录为 JDK8新特性 学习目录，包含JDK8 新增全部特性的介绍。

       如需了解，请跳转链接查看：我是跳转链接

博主搬砖不易，来个关注呗

求关注、求点赞，加个关注不迷路 ヾ(◍°∇°◍)ﾉﾞ

原创：

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/yangsanluo/p/14318176.html