Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。
示例：

import java.util.Optional;
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8Tester = new Java8Tester();
      Integer value1 = null;
      Integer value2 = new Integer(10);
      // Optional.ofNullable - 允许传递为 null 参数
      Optional<Integer> a = Optional.ofNullable(value1);
      // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException
      Optional<Integer> b = Optional.of(value2);
      System.out.println(java8Tester.sum(a,b));
   }
   public Integer sum(Optional<Integer> a, Optional<Integer> b){
      // Optional.isPresent - 判断值是否存在
      System.out.println("第一个参数值存在: " + a.isPresent());
      System.out.println("第二个参数值存在: " + b.isPresent());
      // Optional.orElse - 如果值存在，返回它，否则返回默认值
      Integer value1 = a.orElse(new Integer(0));
      //Optional.get - 获取值，值需要存在
      Integer value2 = b.get();
      return value1 + value2;
   }
}

测试实体User

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String id;
    private String name;
    private Integer age;
    private LocalDate birthday;
    public User(String name) {
        this.name = name;
    }
}

测试方法

private static User createUser(String id) {
        log.info("执行了生成方法:::id===>{}", id);
        return new User(id, "小米" + id, 18, LocalDate.now());
    }

    private static User getNull() {
        return null;
    }

一、Optional 常用方法及使用示例

1、静态方法

empty(),of(T value),ofNullable(T value)

1.1、of(T value),

• 方法作用： 为指定的值创建一个指定非 null 值的 Optional。
• 方法描述： of 方法通过工厂方法创建 Optional 实例，需要注意的是传入的参数不能为 null，否则抛出 NullPointerException。
• 返回类型： Optional

public static void testOf() {
        // 传入正常值，正常返回一个 Optional 对象
        Optional<User> optional1 = Optional.of(createUser("1"));
        log.info("{}", optional1);

        // 传入参数为 null，抛出 NullPointerException.
        Optional<User> optional2 = Optional.of(getNull());
        log.info("{}", optional2);
    }

可以看到传入正常参数正常返回 Optional 对象，传入 null 参数返回 NullPointerException 异常。

1.2、empty()

源码：

public final class Optional<T> {
    //省略....
    private static final Optional<?> EMPTY = new Optional<>();
    private Optional() {
        this.value = null;
    }
    //省略...
    public static<T> Optional<T> empty() {
        @SuppressWarnings("unchecked")
        Optional<T> t = (Optional<T>) EMPTY;
        return t;
    }
}

empty（）的作用就是返回EMPTY对象。

1.3、ofNullable()

• 方法作用： 为指定的值创建一个 Optional 对象，如果指定的参数为 null，不抛出异常，直接则返回一个空的 Optional 对象。
• 方法描述： ofNullable 方法是和 of 方式一样，都是用于创建 Optional 对象，只是传入的参数 null 时，会返回一个EMPTY对象，而不会抛出 NullPointerException 异常。
• 返回类型： Optional

public static void testOfNullable() {
        // 传入正常值，正常返回一个 Optional 对象
        Optional<User> optional1 = Optional.ofNullable(createUser("1"));
        log.info("{}", optional1);
        // 传入 null 参数，正常返回 Optional 对象
        Optional<User> optional2 = Optional.ofNullable(null);
        log.info("{}", optional2);
    }

可以观察到正常传入值和传入 null 值时，都没有抛出异常。

该方法在开发中使用最多的

2、对象方法

• orElse(T other)
• orElseGet(Supplier other)
• orElseThrow(Supplier exceptionSupplier)

这三个函数都是在构造函数传入的value值为null时，进行调用的。

2.1、orElse()

• 方法作用： 如果该值存在就直接返回， 否则返回指定的其它值。
• 方法描述： orElse 方法实现很简单，就是使用三目表达式对传入的参数值进行 null 验证，即 value != null ? value : other; 如果为 null 则返回 true，否则返回 false。

• 返回类型： T

  2.2、对象方法 orElseGet()

• 方法作用： 如果该值存在就返回值，否则触发 other，并返回 other 调用的结果。

• 方法描述： orElseGet 方法和 orElse 方法类似，都是在 Optional 值为空时，返回一个默认操作，只不过 orElse 返回的是默认值，而 orElseGet 是执行 lambda 表达式，然后返回 lambda 表达式执行后的结果。
• 返回类型： T

public static void testOrElseAndOrElseGet() {
        //传入一个空值的情况
        User user1 = getNullUser();
        User user2 = getNullUser();
        user1 = Optional.ofNullable(user1).orElse(createUser("1"));
        user2 = Optional.ofNullable(user2).orElseGet(() -> createUser("2"));
        log.info("当值为null时，orElse" + JSON.toJSONString(user1));
        log.info("当值为null时，orElseGet" + JSON.toJSONString(user2));
        //传入不为空值的情况
        User user3 = createUser("10086");
        User user4 = createUser("10000");
        user3 = Optional.ofNullable(user3).orElse(createUser("3"));
        user4 = Optional.ofNullable(user4).orElseGet(() -> createUser("4"));

        log.info("当值不为null时，orElse" + JSON.toJSONString(user3));
        log.info("当值不为null时，orElseGet" + JSON.toJSONString(user4));
    }

执行结果如下：

结论：
当 Optional 值为空时：
orElse()和orElseGet()都会返回执行的结果

当 Optional 值不为空时：
orElse()会执行其中的方法，但是orElseGet()不会执行

2.3、对象方法 orElseThrow()

• 方法作用： 如果 Optional 存在该值，返回包含的值，否则抛出由 Supplier 继承的异常。
• 方法描述： orElseThrow 方法其实就是判断创建 Optional 时传入的参数是否为 null，如果是非 null 则返回传入的值，否则抛出 异常。
• 返回类型： T

public static void testOrElseThrow(){
        // 传入 null 参数，获取一个 Optional 对象，并使用 orElseThrow 方法
        User user2 = getNull();
        User object2 = Optional.ofNullable(user2).orElseThrow(() -> new RuntimeException("参数为空===>抛出异常"));
        log.info("输出的值为：" + object2);
    }

可以观察到，当创建 Optional 时如果传入的参数为空则执行 Lambda 表达式代码逻辑后抛出异常信息，否则返回传入的参数值。

3、转换值方法

• map(Function mapper)
• flatMap(Function> mapper)

这两个函数，在函数体上没什么区别。
唯一区别的就是入参
map的入参类型为Function<? super T, ? extends U>
flapMap的入参类型为Function<? super T, Optional>

public static void testMap() {
        // 创建 map 对象
        Map<String, User> userMap = new HashMap<>();
        userMap.put("user1", createUser("1"));
        userMap.put("user2", getNull());

        //String name1 = Optional.ofNullable(userMap.get("user1")).map(value -> value.getName()).get();
        String name1 = Optional.ofNullable(userMap.get("user1")).map(User::getName).get();
        log.info("获取值===>{}", name1);
        // 传入 Map 对象参数，获取一个 Optional 对象，获取 user2 属性
        //String name2 = Optional.ofNullable(userMap.get("user2")).map(value -> value.getName()).get();
        String name2 = Optional.of(Optional.ofNullable(userMap.get("user2")).orElse(createUser("0000"))).map(User::getName).get();
        log.info("获取值===>{}", name2);
    }

public static void testFilter() {
        // 创建一个测试的 Optional 对象
        Optional<User> optional = Optional.of(createUser("100"));

        // 调用 Optional 的 filter 方法，设置一个满足的条件，然后观察获取的 Optional 对象值是否为空
        optional = optional.filter((value) -> value.getAge() > 2);
        log.info("Optional 的值不为空：：" + optional.isPresent());

        // 调用 Optional 的 filter 方法，设置一个不满足的条件，然后观察获取的 Optional 对象值是否为空
        optional = optional.filter((value) -> value.getAge() < 2);
        log.info("Optional 的值不为空：：" + optional.isPresent());
    }

 // 创建一个测试的用户集合
        List<User> userList = new ArrayList<>();

        // 创建几个测试用户
        User user1 = new User("abc");
        User user2 = new User("efg");
        User user3 = null;

        // 将用户加入集合
        userList.add(user1);
        userList.add(user2);
        userList.add(user3);

        // 创建用于存储姓名的集合
        List<String> nameList = new ArrayList();
        // 循环用户列表获取用户信息，值获取不为空且用户以 a 开头的姓名，
        // 如果不符合条件就设置默认值，最后将符合条件的用户姓名加入姓名集合
        for (User user : userList) {
            nameList.add(Optional.ofNullable(user).map(User::getName).filter(value -> value.startsWith("a")).orElse("未填写"));
        }

        // 输出名字集合中的值
        System.out.println("通过 Optional 过滤的集合输出：");
        nameList.stream().forEach(System.out::println);

if(user!=null){
    dosomething(user);
}

//Java8
 Optional.ofNullable(user)
    .ifPresent(u->{
        dosomething(u);
});