Java8 Optional常见用法

比眉伴天荒 2024-03-30 17:41 69阅读 0赞

#### 目录 ####

*  Optional简介
 *   *  创建Optional对象
     *   *  of 和 ofNullable 区别
     *  使用场景：使用filter剔除特定的值（\`filter\`）
     *  使用场景： （\`map\`）
     *  使用场景：（\`flatMap\`）
     *  使用场景：（\`ifPresent()\`、\`get()\`）
     *  使用场景：存在就开干（\`ifPresent(Consumer<? super T>)\`）
     *  使用场景：存在则返回，无则返回默认值（\`orElse\`）
     *  使用场景3：存在则返回，无则调函数（\`orElseGet\`）
     *  使用场景4 - 存在则返回，无则抛异常（\`orElseThrow\`）

## Optional简介 ##

Optional类（java.util.Optional）是一个容器类，代表一个值存在或不存在。Java 8的库设计人员引入了Optional，这样就不用返回众所周知容易出问题的`null`了。

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">empty</td> 
   <td align="left">返回一个空的Optional实例</td> 
  </tr> 
  <tr> 
   <td align="left">of</td> 
   <td align="left">将指定值用Optional封装之后返回，如果该值为null，则抛出一个<code>NullPointerException</code>异常</td> 
  </tr> 
  <tr> 
   <td align="left">ofNullable</td> 
   <td align="left">将指定值用Optional封装之后返回，如果该值为null，则返回一个空的Optional对象</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">filter</td> 
   <td align="left">如果值存在并且满足提供的谓词，就返回包含该值的Optional对象；否则返回一个空的Optional对象</td> 
  </tr> 
  <tr> 
   <td align="left">map</td> 
   <td align="left">如果值存在，就对该值执行提供的mapping函数调用</td> 
  </tr> 
  <tr> 
   <td align="left">flatMap</td> 
   <td align="left">如果值存在，就对该值执行提供的mapping函数调用，返回一个Optional类型的值，否则就返回一个空的Optional对象</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">ifPresent(Consumer&lt;? super T&gt;)</td> 
   <td align="left">让你能在变量值存在时执行一个作为参数传入的方法，否则就不进行任何操作</td> 
  </tr> 
  <tr> 
   <td align="left">isPresent()</td> 
   <td align="left">如果值存在就返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td align="left">T get()</td> 
   <td align="left">如果该值存在，将该值用Optional封装返回，否则抛出一个<code>NoSuchElementException</code>异常</td> 
  </tr> 
  <tr> 
   <td align="left"></td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">orElse</td> 
   <td align="left">如果有值则将其返回，否则返回一个默认值</td> 
  </tr> 
  <tr> 
   <td align="left">orElseGet</td> 
   <td align="left">如果有值则将其返回，否则返回一个由指定的Supplier接口生成的值</td> 
  </tr> 
  <tr> 
   <td align="left">orElseThrow</td> 
   <td align="left">如果有值则将其返回，否则抛出一个由指定的Supplier接口生成的异常</td> 
  </tr> 
 </tbody> 
</table>

\-----------------------------------------------------------------------------以上读书笔记摘自 书名：Java 8实战 作者：\[英\] Raoul-Gabriel Urma \[意\] Mario Fusco \[英\] Alan M

### 创建Optional对象 ###

1. 声明一个空的Optional
    
    Optional<Car> optCar = Optional.empty();

2. 依据一个非空值创建Optional
    
    Optional<Car> optCar = Optional.of(car);

3. 可接受null的Optional
    
    Optional<Car> optCar = Optional.ofNullable(car);

#### of 和 ofNullable 区别 ####

of不允许参数为null否则`NullPointerException`

Optional.of(person).orElse(new Person());

ofNullable无限制

Optional.ofNullable(person).orElse(new Person());

### 使用场景：使用filter剔除特定的值（`filter`） ###

Insurance insurance = ...;
    if(insurance != null && "CambridgeInsurance".equals(insurance.getName())){
        
       System.out.println("ok");
    }
    
    Optional<Insurance> optInsurance = ...;
    optInsurance.filter(insurance ->"CambridgeInsurance".equals(insurance.getName()))
                .ifPresent(x -> System.out.println("ok"));

### 使用场景： （`map`） ###

String name = null;
    if(insurance != null){
        
        name = insurance.getName();
    }
    
    Optional<String> name = Optional.ofNullable(insurance).map(Insurance::getName);

夺命连环null检查
    
    public static String getName() {
        
        Person person = findPerson();
        return Optional.ofNullable(person)
                .map(Person::getName)
                .map(name -> name.toLowerCase(Locale.ROOT))
                .orElse("not found");
    }

public class School1 {
        
        private Clbum1 clbum;
        public Clbum1 getClbum() {
        
            return clbum;
        }
    }
    class Clbum1 {
        
        private Student student;
        public Student getStudent() {
        
            return student;
        }
    }
    class Student {
        
        private String name;
        public String getName() {
        
            return name;
        }
    }
    public String getStudentName1(School1 school) {
        
        return Optional.ofNullable(school)
                .map(school1 -> school1.getClbum())
                .map(clbum1 -> clbum1.getStudent())
                .map(Student::getName)
                .orElse("false");
    }

### 使用场景：（`flatMap`） ###

public class School {
        
        private Optional<Clbum> clbum;
        public Optional<Clbum> getClbum() {
        
            return clbum;
        }
    }
    class Clbum {
        
        private Optional<Student> student;
        public Optional<Student> getStudent() {
        
            return student;
        }
    }
    class Student {
        
        private String name;
        public String getName() {
        
            return name;
        }
    }
    public String getStudentName(School school) {
        
        return Optional.ofNullable(school)
                .flatMap(school1 -> school1.getClbum())
                .flatMap(clbum1 -> clbum1.getStudent())
                .map(Student::getName)
                .orElse("false");
    }
    
    flatMap比Map容易空指针，这里还没发现啥好方法想Map一样完美解决夺命连环null判断，对比测试如下
    
    CommonScenarios cl = new CommonScenarios();
    String studentName = cl.getStudentName(new School());
    System.out.println(studentName);
    
    执行结果
    java.lang.NullPointerException
    
    CommonScenarios cl = new CommonScenarios();
    String str = cl.getStudentName1(new School1());
    System.out.println(str);
    
    执行结果
    false

### 使用场景：（`ifPresent()`、`get()`） ###

Optional opt = getIntOptional();
    if(opt.isPresent()) {
        
        Integer value = opt.get();
        // do something with value
    }

### 使用场景：存在就开干（`ifPresent(Consumer<? super T>)`） ###

Person person = null;
    Optional.ofNullable(person).ifPresent(System.out::println);
    输出：
    
    Person person = new Person();
    Optional.ofNullable(person).ifPresent(System.out::println);
    输出：
    Person(name=null, age=null, number=null)

### 使用场景：存在则返回，无则返回默认值（`orElse`） ###

public static Person test() {
        
        Person person = findPerson();
        return Optional.ofNullable(person).orElse(new Person());
    }

### 使用场景3：存在则返回，无则调函数（`orElseGet`） ###

public static Person test1() {
        
        Person person = findPerson();
        return Optional.ofNullable(person).orElseGet(() -> getPerson());
    }
    public static Person getPerson() {
        
        return new Person();
    }

### 使用场景4 - 存在则返回，无则抛异常（`orElseThrow`） ###

Optional.ofNullable(person).orElseThrow();
    
    Optional.ofNullable(person).orElseThrow(()->new IllegalArgumentException());