java.util.Optional

API文档：https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html

• https://www.runoob.com/java/java8-optional-class.html 
• https://blog.csdn.net/qq_40794973/article/details/86882454#t60

• 臭名昭著的空指针异常是导致Java应用程序失败的最常见原因；以前为了解决空指针异常，Google公司著名的Guava项目引入了Optional类，Guava通过使用检查空值的方式来防止代码污染，它鼓励程序员写更干净的代码；受到Google Guava的启发Optional类已经成为Java 8类库的一部分
• Optional实际上是个容器，它可以保存类型T的值，或者仅仅保存null，Optional提供很多有用的方法，这样我们就不用显式进行空值检测
• Optional类的Javadoc描述如下：这是一个可以为null的容器对象，如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象；
• Optional<T> 类(java.util.Optional) 是一个容器类，代表一个值存在或不存在，原来用 null 表示一个值不存在，现在 Optional可以更好的表达这个概念，并且可以避免空指针异常

// import lombok.Data;
@Data
public class User {
    private Address address;
    public User(){}
    public User(Address address){this.address = address;}
}
@Data
public class Country {
   private String isoCode;
    public Country(){}
    public Country(String isoCode){this.isoCode = isoCode;}
}
@Data
public class Address {
    private Country country;
    public Address(){}
    public Address(Country country) {this.country = country;}
}

public class Main {
    public static void main(String[] args) {
        Country country = new Country("hehe");
        Address address = new Address(country);
        User user = new User(address);
        String isoCode = user.getAddress().getCountry().getIsoCode().toUpperCase();
        System.out.println("isoCode => " + isoCode);
        System.out.println("isoCode => " + getIsoCode(user));
        //isoCode => HEHE
        //isoCode => HEHE
    }
    public static String getIsoCode(User user) {
        String isoCode = null;
        if (user != null) {
            Address address = user.getAddress();
            if (address != null) {
                Country country = address.getCountry();
                if (country != null) {
                    isoCode = country.getIsoCode();
                    if (isoCode != null) {
                        isoCode = isoCode.toUpperCase();
                    }
                }
            }
        }
        return isoCode;
    }
}

类方法

方法	描述
<T> Optional<T> empty()	创建一个空的Optional实例
<T> Optional<T> of(T value)	创建一个指定非null值的Optional实例
<T> Optional<T> ofNullable(T value)	若value不为 null，创建Optional 实例，否则创建空实例
isPresent()	如果值存在则方法会返回true，否则返回 false
T get()	如果调用对象包含值，返回该值，否则抛异常
T orElse(T other)	如果调用对象包含值，返回该值，否则返回other
T orElseGet(Supplier<? extends T> other)	如果调用对象包含值，返回该值，否则触发 other，并返回 other 调用的结果
map(Function<? super T, ? extends U> mapper)	如果有值对其处理，并返回处理后的Optional，否则返回 Optional.empty()
flatMap(Function<? super T, Optional<U>> mapper)	与 map 类似，要求返回值必须是Optional

@Test
public void testOf(){
    Optional<Object> op = Optional.of(new Object());
    Object obj = op.get();
    System.out.println(obj);
}

@Test
public void test() {
    //Optional<Object> op = Optional.of(null); // 这样是不可以的，这样可以以最快的速度定位异常

    //有的时候我就想构建一个空的Optional的
    Optional<Object> op2 = Optional.empty();
    System.out.println(op2.get());

    //ofNullable 是另外两个的综合
    //public static <T> Optional<T> ofNullable(T value) {
    //     return value == null ? empty() : of(value);
    //}
    Optional<Object> op3 = Optional.ofNullable(null);
    System.out.println(op3.get());
}

@Test
public void test() {
    Pair<String, String> user = null;//new Pair<>("name", "卢本伟");
    Optional<Pair<String, String>> op = Optional.ofNullable(user);
    if (op.isPresent()) {
        System.out.println(op.get());
    }

    Pair emp = op.orElse(new Pair<>("name", "乔碧萝"));
    System.out.println(emp);

    //和上面的相比，这个可以添加判断
    Object emp2 = op.orElseGet(() -> new Pair<>("name", "蔡徐坤"));
    System.out.println(emp2);
}

@Test
public void test() {
    Optional<Pair<String, String>> op = Optional.of(new Pair<>("name", "卢本伟"));

    Optional<String> op2 = op.map(Pair::getValue);
    System.out.println(op2.get());

    //进一步避免异常
    Optional<String> op3 = op.flatMap((user) -> Optional.of(user.getValue()));
    System.out.println(op3.get());
}

https://www.cnblogs.com/zhangboyu/p/7580262.html