java8中Optional的用法详解

package com.lyzx.concurrent.java8;

import org.junit.Test;

import java.util.Optional;
import java.util.Random;

public class OptionalTest {

    /**
     * Optional.of(T t)创建一个Optional
     *   >> 底层有一个泛型T的value，如果t不是null就赋值给value
     * isPresent()判断是否存在
     *   >> return value != null
     * get() 获取泛型T的实例t
     *   >>如果value != null 就返回value，否则抛出异常
     * Optional.empty()返回一个空Optional对象
     *
     */
    @Test
    public void test1(){
        Optional<Java8> op1 = Optional.of(new Java8("first"));
        System.out.println(op1.get()+"   "+op1.isPresent());

        Optional op2 = Optional.empty();
        System.out.println(op2.isPresent()+"   "+ op2.get());
    }

    /**
     * Optional.ofNullable(T t)
     *   >> return value == null ? empty() : of(value)
     *
     */
    @Test
    public void test2(){
//        Optional op1 = Optional.ofNullable(new Java8("王二狗"));

        Java8 j = null;
        Optional<Java8> op1 = Optional.ofNullable(j);
        System.out.println(op1.isPresent()+"   "+op1.isPresent());
        System.out.println(op1.orElse(new Java8("李铁蛋")));
    }

    /**
     * orElseGet(fun) 如果isPresent()==false 通过一个函数生成一个泛型T的对象t
     */
    @Test
    public void test3(){
        Java8 j = null;//new Java8("AA");//null;
        Optional<Java8> op1 = Optional.ofNullable(j);

        Java8 j2 = op1.orElseGet(()->{
                    String[] arr = {"王大锤","张铁蛋","大球娃"};
                    Random rand = new Random();
                    return new Java8(arr[rand.nextInt(arr.length)]);
                });
        System.out.println(j2);
    }

    @Test
    public void test4(){
        Man man = new Man("余承东",new TargetPhone("P20 Pro"));
        String phoneName = TralditionalMethod(man);
        System.out.println(phoneName);

        System.out.println(TralditionalMethod(null));
    }

    /**
     * 通过传统的方式获取一个嵌套对象中的属性
     * 需要不停的判断某个属性是否为null
     * @param man
     * @return
     */
    public String TralditionalMethod(Man man){
        if(null != man){
            TargetPhone phone = man.getPhone();
            if(null != phone){
                String phoneName = phone.getPhoneName();
                return phoneName;
            }
        }
        return "小米Mix2S";
    }

    @Test
    public void test5(){
//        XMan xman = new XMan("罗永浩",Optional.of(new TargetPhone("锤子T3")));
//        Optional op = Optional.ofNullable(xman);

        Optional op = Optional.empty();
        System.out.println(newMethod(op));
    }

    /**
     * 通过新方式获取某个属性的值，
     * 需要改造类的属性，把其有可能出现null的属性封装为Optional
     * @param man
     * @return
     */
    public String newMethod(Optional<XMan> man){
        return man.orElse(new XMan("雷军",Optional.of(new TargetPhone("小米Mix2S"))))
                .getPhone()
                .get()
                .getPhoneName();
    }

   /**
     * 测试 ifPresent 方法<br/>
     * 只有在op不为空时才执行,为空是不执行
     */
    @Test
    public void test6(){
        String data = null;//"1,2,3";
        Optional<String> op = Optional.ofNullable(data);

        op.ifPresent(x->{
            for(String v : x.split(",")){
                System.out.println("--"+v);
            }
        });

        if(op.isPresent())
            System.out.println(op.get());
    }

    /**
     * orElse()和orElseGet()方法都是op不为空时返回get()的值，为空时返回参数里面的值
     * 不同点在于
     *     orElse()方法op是不是为空，都会执行参数参入的方法
     *     orElseGet()方法在对象不为空时直接返回get()的值
     *
     *  orElseThrow()当op为空时直接抛出异常
     */
    @Test
    public void test7(){
        String data = null;
//        String data = "youzhi";
        Optional<String> op = Optional.ofNullable(data);
        String other = op.orElse(getStr());
        System.out.println("1:"+other);

        System.out.println("===================");
        String elseGet = op.orElseGet(()->getStr());
        System.out.println("2:"+elseGet);


        op.orElseThrow(()->new IllegalArgumentException("参数为空"));
    }

    public String getStr(){
        System.out.println("getStr()被调用......");
        return "getStrValue";
    }


    /**
     * map()和flatMap()方法在不为空时调用
     */
    @Test
    public void test8(){
        Man man = new Man("提姆库克",new TargetPhone("iphoneX"));
//        Man man = null;
        Optional<Man> op = Optional.ofNullable(man);
        String ss = op.map(x -> x.getManName()).orElseGet(() -> "默认值");
        System.out.println(ss);

        TargetPhone t3 = op.map(x -> x.getPhone()).orElseGet(() -> new TargetPhone("T3"));
        System.out.println(t3.getPhoneName());
    }

    /**
     * Optional的常用方法举例
     * 这样做比较好的是看着很清爽而且没有烦人的空指针异常
     */
    @Test
    public void test9(){
//        Man man = new Man("提姆库克",new TargetPhone("iphoneX"));
        Man man = null;
        Optional<Man> op = Optional.ofNullable(man);
        String iphoneName = op.map(x->x.getPhone())
                              .map(x->x.getPhoneName())
                              .orElse("默认值");

        System.out.println(iphoneName);
    }


    /**
     * filter的过滤作用
     */
    @Test
    public void test10(){
        Man man = new Man("提姆库克",new TargetPhone("iphoneX"));
        Optional<Man> op = Optional.ofNullable(man);
        Optional<TargetPhone> phone = op.map(x -> x.getPhone())
                .filter(x -> x.getPhoneName().length() > 5);
        System.out.println(phone.orElse(new TargetPhone("最好的战斗机")).getPhoneName());

    }

}

class Java8{
    private String name;

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

    @Override
    public String toString() {
        return "Java8{" +
                "name='" + name + '\'' +
                '}';
    }
}

class Man{
    private String manName;
    private TargetPhone phone;

    public Man(String manName,TargetPhone phone){
        this.manName=manName;
        this.phone = phone;
    }

    public String getManName() {
        return manName;
    }

    public TargetPhone getPhone() {
        return phone;
    }

    @Override
    public String toString() {
        return "Man{" +
                "manName='" + manName + '\'' +
                ", phone=" + phone +
                '}';
    }
}

class TargetPhone{
    private String phoneName;

    public TargetPhone(String phoneName){
        this.phoneName = phoneName;
    }

    public String getPhoneName(){
        return phoneName;
    }
}

class XMan{
    private String manName;
    private Optional<TargetPhone> phone;

    public XMan(String manName,Optional<TargetPhone> phone){
        this.manName = manName;
        this.phone = phone;
    }

    public String getManName() {
        return manName;
    }

    public Optional<TargetPhone> getPhone() {
        return phone;
    }

    @Override
    public String toString() {
        return "XMan{" +
                "manName='" + manName + '\'' +
                ", phone=" + phone +
                '}';
    }
}