Optional 用法

Optional 类的引入很好的解决空指针异常，它可以保存类型T的值，或者仅仅保存null；
下面讲解常见用法
1：ofNullable
    括号里面是否为null  为null则设置新对象
2：orElse
    前面ofNullable括号里面是否  为null   为null则新建对象
3：ifPresent
    前面ofNullable括号里面是否  不为null    不为null则执行方法
4：filter
    前面ofNullable括号里面是否  不为null 则进行对比 不正确则设置原对象变为新对象
    
         //optional 依旧有Optional 的所有方法
    Optional optional = Optional.ofNullable(null);
         //object 已经没有Optional 的方法了
    Object object = Optional.ofNullable(null);


 Optional源码分析：
 
     //判断ofNullable里面的对象对象是否为NUll  
    public static <T> Optional<T> ofNullable(T value) {   
        return value == null ? empty() : of(value);
    }

    //为Null 则新建一个new Optional （Object）对象  该对象的 value=null
    public static<T> Optional<T> empty() {    
        Optional<T> t = (Optional<T>) new Optional<>();
        return t;
    }    
    
    //不为Null 则返回对象  同时使得  value  等于 该对象
    public static <T> Optional<T> of(T value) {    
        return new Optional<>(value);
    }
    
        
    Person person = new Person();
    person.setName("HeSuiJin");
    
    Object personTemp2 = Optional.ofNullable(null).orElse(new Person());
    log.info("我是Person啊:{}", JSONObject.toJSONString(personTemp2));
    
    Object personTemp1 = Optional.ofNullable(person).orElse(new Person());
    log.info("我是Person啊:{}", JSONObject.toJSONString(personTemp1));
    

    Optional源码分析：orElse
  
    //Optional类型的对象 紧接着去调用该方法 
    //如果是New出来的 Optional 则 value =null
    //如果 value！=null 则返回原来的对象 value  如果为null  则返回新对象 other
    public T orElse(T other) {    
        return value != null ? value : other;
    }
   
   
        Optional.ofNullable(person).ifPresent(
             a->  System.out.println(JSONObject.toJSONString(a))
        );

     Optional源码分析：ifPresent
     
     // ifPresent 入参为  Consumer类型的 lambda表达式
     //当 value != null 时重写 accept方法
     //入参为 value（对象）
     
    public void ifPresent(Consumer<? super T> consumer) {    
        if (value != null)        
        consumer.accept(value);
    }


Optional<Person> person = Optional.ofNullable(person).filter(
        a -> "我的名字".equals(a.getName())
);


Optional源码分析：filter

//filter入参为  Predicate类型的 lambda表达式
//isPresent 为   value非空      

// ！isPresent 为value空    则返回：new Optional （Object）对象  
        //否则 重写test(value)方法
             //成立   则返回原本的对象
             //不成立  则返回 ：new Optional （Object）对象  

public Optional<T> filter(Predicate<? super T> predicate) {  
    Objects.requireNonNull(predicate);   
    if (!isPresent())       
         return this;    
    else        
         return predicate.test(value) ? this : empty();
   }