JDK8之使用Optional链式编程实践demo

package com.hierway.pmcs.marm.test;

import com.hierway.pmcs.marm.entity.Requisition;
import com.hierway.utility.api.result.ApiException;
import com.hierway.utility.api.result.ResultCode;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;

/**
 * @Description
 * @Author by mocar小师兄
 * @Date 2020/9/10 10:29
 **/
public class PSVMTest {
    public static void main(String[] args) {
        System.out.println("----------   testOfNullable   -----------");
        testOfNullable();

        System.out.println("----------   testIfPresent   -----------");
        testIfPresent();

        System.out.println("----------   testOrElse   -----------");
        testOrElse();

        System.out.println("----------   testOrElseGet   -----------");
        testOrElseGet();

        System.out.println("----------   testOrElseThrow   -----------");
        testOrElseThrow();

        System.out.println("----------   testFilter   -----------");
        testFilter();

        System.out.println("----------   demoTest   -----------");
        demoTest();
    }

    private static void demoTest(){
        String hel = null;
        String aThrow = Optional.ofNullable(hel).map(a -> a + "kkk")
                .map(b -> b + "mmm")
                .orElseThrow(() -> new IllegalStateException("为空"));
        System.out.println(aThrow);
    }


    private static void testOfNullable(){
        //Optional.of()或者Optional.ofNullable()：建立Optional对象，差异在于of不容许参数是null，而ofNullable则无限制。

//        List<String> testList = new ArrayList<>();
//        List<String> testList = null;
//        List<String> testList = Arrays.asList("a","111","sda");
        Optional<Object> optionalO = Optional.ofNullable(null);
        List<String> testList = new ArrayList<>();
        Optional<Object> optionalO2 = Optional.ofNullable(testList);

        //isPresent()：判断值是否存在
        System.out.println("判断值是否为null:" + optionalO.isPresent());
        System.out.println("判断值是否为null:" + optionalO2.isPresent());
    }

    private static void testIfPresent(){
        //对象不为null 则调用consumer对象  ，不然不调用
        List<String> testList2 = Arrays.asList("a","111","sda");
        Optional.ofNullable(testList2).ifPresent((consumer)-> System.out.println("对象不为null,执行consumer对象逻辑" + consumer));
        Optional.ofNullable(testList2).ifPresent((consumer)-> {
            for (String s : consumer) {
                System.out.println(s);
            }
        });

        List<Requisition> testList3 = new ArrayList<>();
        Requisition requisition1 = Requisition.builder().id("id1").appointerId("appointerId1").createTime(LocalDateTime.now()).build();
        Requisition requisition2 = Requisition.builder().id("id2").appointerId("appointerId2").createTime(LocalDateTime.now()).build();
        testList3.add(requisition1);
        testList3.add(requisition2);
        Optional.ofNullable(testList3).ifPresent((consumer)-> {
            for (Requisition requisition : consumer) {
                System.out.println(requisition);
            }
        });
    }


    private static void testOrElse(){
        List<String> testList = null;
        if (1 ==0){
            testList = Arrays.asList("aa","bb");
        }
        List<String> testList2 = Arrays.asList("mm");
        //若是optional对象保存的值不是null，则返回原来的值，不然返回value,若是为空则取else的值
        System.out.println(Optional.ofNullable(20).orElse(100));
        List<String> orElseList = Optional.ofNullable(testList).orElse(testList2);
        System.out.println(orElseList);

    }

    private static void testOrElseGet(){
        //若是optional对象保存的值不是null，则返回原来的值，不然返回value,若是为空则执行else对象方法（return对象）
        List<String> testList = null;
        if (1 ==0){
            testList = Arrays.asList("aa","bb");
        }
        List<String> orElseGetList = Optional.ofNullable(testList).orElseGet(() -> {
            List<String> testList2 = Arrays.asList("mm");
            return testList2;
        });
        System.out.println(orElseGetList);
    }



    private static void testOrElseThrow(){
        //值为null则抛出异常，存在则什么不作，有点相似Guava的Precoditions
        List<String> testList = null;
        if (1 == 0){
            testList = Arrays.asList("aa","bb");
        }
        try {
                Optional.ofNullable(testList).orElseThrow(()->new IllegalStateException("参数为空"));
        }
        catch(IllegalStateException e )
        {
            e.printStackTrace();
        }
    }

    private static void testFilter(){
        //值为null则抛出异常，存在则什么不作，有点相似Guava的Precoditions
        List<String> testList = Arrays.asList("aa","bb");
        Optional<List<String>> optional = Optional.ofNullable(testList).filter((aa) -> aa.contains("aa"));
        System.out.println(optional.isPresent());
        System.out.println(optional.get());

        boolean present = Optional.ofNullable(1).filter(aa -> aa.intValue() == 2).isPresent();
        System.out.println(present);
    }

}