Optional容器类

 

public class Godness {

    private String name;

    public Godness() {
    }

    public Godness(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Godness [name=" + name + "]";
    }

}

public class Man {

    private Godness god;

    public Man() {
    }

    public Man(Godness god) {
        this.god = god;
    }

    public Godness getGod() {
        return god;
    }

    public void setGod(Godness god) {
        this.god = god;
    }

    @Override
    public String toString() {
        return "Man [god=" + god + "]";
    }

}

//注意：Optional 不能被序列化,分布式开发不用
public class NewMan {

    private Optional<Godness> godness = Optional.empty();

    private Godness god;

    public Optional<Godness> getGod(){
        return Optional.of(god);
    }

    public NewMan() {
    }

    public NewMan(Optional<Godness> godness) {
        this.godness = godness;
    }

    public Optional<Godness> getGodness() {
        return godness;
    }

    public void setGodness(Optional<Godness> godness) {
        this.godness = godness;
    }

    @Override
    public String toString() {
        return "NewMan [godness=" + godness + "]";
    }

}

/*
 * 一、Optional 容器类：用于尽量避免空指针异常
 *  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
 */
public class OptionalTest {



    @Test
    public void test1() {
       Optional<Emp> optional = Optional.of( new Emp("3333", "张三", 3333.33, 31,Status.BUSY))  ;
//     Optional<Emp> optional = Optional.of(null)  ;
       Emp emp = optional.get()  ;
       System.out.println(emp)   ;
    }

    @Test
    public void test2(){
//      Optional<Object> optional = Optional.ofNullable(null)  ;
//      System.out.println(optional)  ;
        Optional<Object> optional2 = Optional.empty()  ;
        System.out.println(optional2)  ;
    }

    @Test
    public void test3(){
        //Optional<Emp> optional = Optional.ofNullable( new Emp("3333", "张三", 3333.33, 31,Status.BUSY))  ;
        Optional<Emp> optional = Optional.ofNullable(null)  ;
        if(optional.isPresent())
            System.out.println(optional.get());
        else
            System.out.println(new Emp());
    }

    @Test
    public void test4(){
        Optional<Emp> optional = Optional.ofNullable(new Emp("4444", "李四", 4444.44, 41,Status.FREE))  ;
        Emp emp = optional.orElse(new Emp("3333", "张三", 3333.33, 31,Status.BUSY)) ;
        System.out.println(emp);
    }


    @Test
    public void test5(){
        Optional<Emp> optional = Optional.ofNullable(new Emp("4444", "李四", 4444.44, 41,Status.FREE)) ;
        Emp emp = optional.orElseGet(Emp::new)   ;
        System.out.println(emp);
    }

    @Test
    public void test6(){
        Optional<Emp> optional = Optional.ofNullable(new Emp("4444", "李四", 4444.44, 41,Status.FREE))  ;
        Optional<Emp> map = optional.map((e)->{
            e.setEname("李四四")   ;
            return e ;
        });
        System.out.println(map.isPresent());
    }

    @Test
    public void test7(){
        Optional<Emp> optional = Optional.ofNullable(new Emp("4444", "李四", 4444.44, 41,Status.FREE))  ;
        Optional<Emp> map = optional.flatMap(e->{
               e.setEname("李八蛋") ;
               return Optional.of(e);
        })  ;
        System.out.println(map.get());
    }

    //需求：获取一个男人心中女神的名字
    public String getGodnessName(Man man){
          if(man!=null)
              if(man.getGod()!=null)
                  return man.getGod().getName()   ;
          return "Teacher-Cang"   ;
    }

    //需求[Optional容器板]：获取一个男人心中女神的名字
    public String getGodnessName(Optional<NewMan> man){
          return man.orElse(new NewMan())
                    .getGodness()
                    .orElse(new Godness("Teacher-BoDuo"))
                    .getName()   ;
    }

    @Test
    public void test8(){
        Godness god=new Godness("Teacher-LongZe");
        //Man man=new Man()   ;
        Man man=new Man(god);
        String name = getGodnessName(man);
        System.out.println(name);
    }

    @Test
    public void test9(){
        //String name = getGodnessName(Optional.empty());
        //String name = getGodnessName(Optional.of(new NewMan()));
        Godness godness=new Godness("Teacher-XiaoZeMaLiYa")   ;
        NewMan man=new NewMan(Optional.ofNullable(godness))  ;
        String name = getGodnessName(Optional.of(man));
        System.out.println(name);
    }






}