Optional API介绍

package com.example;

import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;

@Slf4j
@SpringBootTest
public class OptionalTests {

    /**
     * Optional.of
     * 该方法的入参是一个非null值，如果该值为null，则抛出NullPointerException，不为Null则返回该值。
     */
    @Test
    public void OptionalOfTest() {
        try {
            Optional.of(null);
        } catch (NullPointerException e) {
            log.error("发生了空指针异常");
        }

        try {
            Optional.of(100);
            log.info("正常使用");
        } catch (NullPointerException e) {

        }

        Optional<String> optional = Optional.of("美依礼芽");
        log.info(JSONUtil.toJsonStr(optional.get()));
    }

    /**
     * Optional.ofNullable
     * 非Null时返回该值，为null时返回一个Optional.empty()
     */
    @Test
    public void OptionalOfNullableTest() {
        Optional<Object> optional = Optional.empty();
        try {
            optional.get();
        } catch (NoSuchElementException e) {
            log.error("No value present");
            log.error("从空集合中获取元素，会报错");
        }

        Optional<Object> hasElementOptional = Optional.ofNullable("美依礼芽");
        log.info(JSONUtil.toJsonStr(hasElementOptional.get()));
    }

    /**
     * Optional.empty()
     * 通过构造方法返回一个空的Optional实例。
     */
    @Test
    public void OptionalEmptyTest() {
        Optional<Object> emptyOptional = Optional.empty();
        try {
            emptyOptional.get();
        } catch (NoSuchElementException e) {
            log.error("No value present");
            log.error("从空集合中获取元素，会报错");
        }
    }

    /**
     * Optional.get()
     * 获取optional实例中的对象，当 optional 容器为空时报错
     */
    @Test
    public void OptionalGetTest() {
        Optional<Object> optional = Optional.empty();
        try {
            optional.get();
        } catch (NoSuchElementException e) {
            log.error("No value present");
            log.error("从空集合中获取元素，会报错");
        }
    }

    /**
     * Optional.isPresent
     * 判断Optional是否有值
     */
    @Test
    public void OptionalIsPresentTest() {
        Optional<Object> optional = Optional.empty();
//        Optional<Object> optional = Optional.ofNullable("美依礼芽");

        if (optional.isPresent()) {
            log.info("Optional有值{}", optional.get());
        } else {
            try {
                optional.get();
            } catch (NoSuchElementException e) {
                log.error("No value present");
                log.error("从空集合中获取元素，会报错");
            }
        }
    }

    /**
     * Optional.ifPresent
     * 如果optional不为空，则将optional中的对象传给Comsumer函数
     */
    @Test
    public void OptionalIfPresentTest() {
        Optional<Object> optional1 = Optional.ofNullable(null);
        Optional<Object> optional2 = Optional.ofNullable("美依礼芽");

        optional1.ifPresent((result) -> {
            log.info("不会执行");
        });

        optional2.ifPresent((result) -> {
            log.info("Optional有值{}", result);
        });
    }

    /**
     * Optional.orElse(T other)
     * 如果optional不为空，则返回optional中的对象；如果为null，则返回 other 这个默认值
     */
    @Test
    public void OptionalOrElseTest() {
        Object optional1 = Optional.empty().orElse("美依礼芽");
        Object optional2 = Optional.of("亚里士多德").orElse("美依礼芽");
        log.info("optional1：{}", JSONUtil.toJsonStr(optional1));
        log.info("optional2：{}", JSONUtil.toJsonStr(optional2));
    }

    /**
     * Optional.orElseGet(Supplier other)
     * 如果optional不为空，则返回optional中的对象；如果为null，则使用Supplier函数生成默认值other
     */
    @Test
    public void OptionalOrElseGetTest() {
        Object optional1 = Optional.empty().orElseGet(() -> "美依礼芽");
        Object optional2 = Optional.of("亚里士多德").orElseGet(() -> "美依礼芽");
        log.info("optional1：{}", JSONUtil.toJsonStr(optional1));
        log.info("optional2：{}", JSONUtil.toJsonStr(optional2));
        /*
            Optional.orElse(T other) 和 Optional.orElseGet(Supplier other)的区别：
                当对象为空时，作用一样。
                当对象为非空时，Optional.orElse(T other) 依然会调用一次other参数。
          */
        Object optional3 = Optional.of("维也纳").orElse(newName1());
        log.info("optional3：{}", JSONUtil.toJsonStr(optional3));

        Object optional4 = Optional.of("维也纳").orElseGet(this::newName2);
        log.info("optional4：{}", JSONUtil.toJsonStr(optional4));
    }

    public String newName1() {
        log.info("进入执行1");
        return "美依礼芽";
    }

    public String newName2() {
        log.info("进入执行2");
        return "美依礼芽";
    }

    /**
     * Optional.orElseThrow(Supplier exception)
     * 如果optional不为空，则返回optional中的对象；如果为null，则抛出Supplier函数生成的异常
     */
    @Test
    public void OptionalOrElseThrowTest() throws Exception {
        Integer param = null;
        try {
            Optional.ofNullable(param).orElseThrow(() -> new Exception("嘻嘻，异常"));
        } catch (Exception e) {
            log.error("异常信息：", e);
        }

        param = 1000;
        Integer integer = Optional.ofNullable(param).orElseThrow(() -> new Exception("嘻嘻，异常"));
        System.out.println("integer = " + integer);
    }

    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    static
    class Person {
        private String name;
        private Integer age;
    }

    /**
     * Optional.map(Function<T, U> mapper)
     * 如果optional不为空，则将optional中的对象 t 映射成另外一个对象 u，并将 u 存放到一个新的optional容器中
     */
    @Test
    public void OptionalMapTest() {
        List<Person> personList = new ArrayList<>();
        personList.add(new Person("张三", 22));
        personList.add(new Person("李四", 36));
        personList.add(new Person("王五", 45));

        // 可以获取List中的第一个元素，再将第一个元素封装成一个Optional返回
        Optional<Person> person = Optional.of(personList).map((item) -> item.get(0));
        log.info("person = " + person);
    }

    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    static
    class Student {
        private String name;
        private List<Subject> subjects;
    }

    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    static
    class Subject {
        private String type;
        private Double grade;
    }

    /**
     * Optional.flatMap(Function< T,Optional> mapper)
     * 跟上面一样，在optional不为空的情况下，将对象t映射成另外一个optional
     */
    @Test
    public void OptionalFlatMapTest() {
        List<Student> studentList = new ArrayList<>();
        studentList.add(new Student("张三", ListUtil.toList(new Subject("语文", 95.5), new Subject("数学", 91.3), new Subject("英语", 70.8))));
        studentList.add(new Student("李四", ListUtil.toList(new Subject("语文", 92.1), new Subject("数学", 99.0), new Subject("英语", 37.2))));
        studentList.add(new Student("王五", ListUtil.toList(new Subject("语文", 66.3), new Subject("数学", 25.6), new Subject("英语", 99.5))));

        // 注意：两者的区别是map()只有当值不被包裹时才进行转换，而flatmap()接受一个被包裹着的值并且在转换之前对其解包。
        Optional<Double> optional = Optional.of(studentList)
                .flatMap((item) -> {
                    return Optional.of(item.get(2));
                })
                .flatMap((item) -> {
                    return Optional.of(item.subjects);
                })
                .flatMap((item) -> {
                    return Optional.of(item.get(0));
                })
                .map(Subject::getGrade);
        log.info("optional = " + optional);
    }

    /**
     * Optional.filter(Predicate p)
     * 如果optional不为空，则执行断言函数p，如果p的结果为true，则返回原本的optional，否则返回空的optional
     */
    @Test
    public void OptionalFilterTest() {
        Optional<String> optional1 = Optional.of("美依礼芽").filter(item -> StrUtil.equals(item, "美"));
        Optional<String> optional2 = Optional.of("美依礼芽").filter(item -> StrUtil.contains(item, "美"));
        log.info("optional1 = " + optional1);
        log.info("optional2 = " + optional2);
    }
}