java8-12-Optional类

 
Optional类  java.util.Optional   是一个容器类 避免空指针  NPE
 能够快速定位空指针
 
常用方法：
　　Optional.of(T t) : 创建一个 Optional 实例
　　Optional.empty() : 创建一个空的 Optional 实例
　　Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 
　　isPresent() : 判断是否包含值
　　orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
　　orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 
　　map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
　　flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
 
注意;空 空对象  不是一回事  例如 没有房子  空房子
 
 
 
 
 
 
 
 
 
  1 package com.wf.zhang.java8.optional;
  2 
  3 import com.wf.zhang.java8.lamdba.Employee;
  4 import org.junit.Test;
  5 
  6 import java.util.Optional;
  7 
  8 public class TestOptional {
  9 
 10     /**
 11      * 常用方法：
 12      * Optional.of(T t) : 创建一个 Optional 实例
 13      * Optional.empty() : 创建一个空的 Optional 实例
 14      * Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 15      * isPresent() : 判断是否包含值
 16      * orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
 17      * orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 18      * map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
 19      * flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
 20      */
 21 
 22     @Test
 23     public  void  test01(){
 24 
 25         /**
 26          * Optional.of(T t) : 创建一个 Optional 实例
 27          */
 28         //调用无参数构造  产生带默认值的Employee对象
 29         //返回 Employee [ name=null, age=0, salary=0.0, status=null]
 30         Optional<Employee> op = Optional.of(new Employee());
 31         Employee employee = op.get();
 32         System.out.println(employee);
 33 
 34         //java.lang.NullPointerException  不允许传null
 35         Optional<Employee> op2 = Optional.of(null);
 36         System.out.println(op2.get());
 37 
 38     }
 39 
 40     @Test
 41     public void test02(){
 42         /**
 43          * Optional.empty() : 创建一个空的 Optional 实例
 44          */
 45         //java.util.NoSuchElementException: No value present 没有值
 46         Optional<Employee> op = Optional.empty();
 47         System.out.println(op.get());
 48 
 49     }
 50 
 51     @Test
 52     public void test03(){
 53 
 54         /**
 55          * Optional.ofNullable(T t):若 t 不为 null,创建 Optional 实例,否则创建空实例
 56          */
 57         //返回空实例    Optional.empty
 58         Optional<Employee> op = Optional.ofNullable(null);
 59         System.out.println(op);
 60 
 61 
 62 
 63         Optional<Employee> op2 = Optional.ofNullable(new Employee());
 64 
 65         /**
 66          * isPresent() : 判断是否包含值
 67          */
 68         //返回Employee [ name=null, age=0, salary=0.0, status=null]
 69         op2.ifPresent(System.out::println);
 70 
 71 
 72 
 73         /**
 74          * orElse(T t) : 如果调用对象包含值，返回该值，否则返回t
 75          */
 76         //返回 Employee [ name=张三, age=18, salary=0.0, status=null]
 77         Optional<Employee> op3 = Optional.ofNullable(null);
 78         System.out.println(op3.orElse(new Employee("张三",18)));
 79 
 80 
 81 
 82         /**
 83          * orElseGet(Supplier s) :如果调用对象包含值，返回该值，否则返回 s 获取的值
 84          */
 85         //Employee [ name=赵六, age=38, salary=0.0, status=null]
 86         Optional<Employee> op4 = Optional.ofNullable(null);
 87         System.out.println( op4.orElseGet(() -> new Employee("赵六",38)));
 88 
 89 
 90 
 91     }
 92 
 93     @Test
 94     public  void tests04(){
 95 
 96         /**
 97          * map(Function f): 如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
 98          */
 99         Optional<Employee> op = Optional.ofNullable(new Employee());
100         Optional<String> s = op.map((e) -> e.getName());
101         System.out.println(s);   //返回 Optional.empty
102 
103         Optional<Employee> op2 = Optional.ofNullable(new Employee("张三",18));
104         Optional<String> s2 = op2.map((e) -> e.getName());
105         System.out.println(s2);   //返回 Optional[张三]
106     }
107 
108     @Test
109     public  void tests05(){
110 
111         /**
112          * flatMap(Function mapper):与 map 类似，要求返回值必须是Optional
113          */
114         Optional<Employee> op = Optional.ofNullable(new Employee("张三",18));
115         Optional<String> s = op.flatMap((e) ->Optional.of(e.getName()));
116         System.out.println(s);   //返回 Optional[张三]
117 
118 
119         /**传空  使用Optional.of()可以避免空指针
120          *
121          * Optional.ofNullable()     空对象返回 Optional[Employee [ name=null, age=0, salary=0.0, status=null]]
122          * Optional.of()不允许传null  空返回  java.lang.NullPointerException
123          */
124         Optional<Employee> op2 = Optional.ofNullable(new Employee());
125         System.out.println(op2);
126         Optional<String> s2 = op2.flatMap((e) ->Optional.of(e.getName()));
127         System.out.println(s2);
128     }
129 
130 
131 }

 

posted @ 2019-11-10 19:15  wf.zhang  阅读(309)  评论(0)  编辑  收藏  举报