JDK1.8中的Optional使用方式

参考文章
参考文章2

1.方法：

方法	描述
of	把指定的值封装为Optional对象，如果指定的值为null，则抛出NullPointerException
empty	创建一个空的Optional对象
ofNullable	把指定的值封装为Optional对象，如果指定的值为null，则抛出NullPointerException
get	如果创建的Optional中有值存在，则返回此值，否则抛出NoSuchElementException
orElse	把指定的值封装为Optional对象，如果指定的值为null，则抛出NullPointerException
orElseGet	如果创建的Optional中有值存在，则返回此值，否则返回一个由Supplier接口生成的值
orElseThrow	如果创建的Optional中有值存在，则返回此值，否则抛出一个由指定的Supplier接口生成的异常
filter	如果创建的Optional中的值满足filter中的条件，则返回包含该值的Optional对象，否则返回一个空的Optional对象
map	如果创建的Optional中的值存在，对该值执行提供的Function函数调用
flagMap	如果创建的Optional中的值存在，就对该值执行提供的Function函数调用，返回一个Optional类型的值，否则就返回一个空的Optional对象
isPresent	如果创建的Optional中的值存在，返回true，否则返回false
ifPresent	如果创建的Optional中的值存在，则执行该方法的调用，否则什么也不做

2.构造方法

Optional 本质是一个容器，需要我们将对象实例传入该容器中。Optional 的构造方法为 private，无法直接使用 new 构建对象，只能使用 Optional 提供的静态方法创建。

Optional 三个创建方法如下：

• Optional.of(obj),如果对象为 null，将会抛出 NPE。
• Optional.ofNullable(obj),如果对象为 null,将会创建不包含值的 empty Optional 对象实例。
• Optional.empty() 等同于 Optional.ofNullable(null)

3.方法实列：

3.1 of

//创建一个值为张三的String类型的Optional
Optional<String> ofOptional = Optional.of("张三");
//如果我们用of方法创建Optional对象时，所传入的值为null，则抛出NullPointerException如下图所示
Optional<String> nullOptional = Optional.of(null);

3.2 ofNullable

//为指定的值创建Optional对象，不管所传入的值为null不为null，创建的时候都不会报错
Optional<String> nullOptional = Optional.ofNullable(null);
Optional<String> nullOptional = Optional.ofNullable("lisi");

3.3 empty

//创建一个空的String类型的Optional对象
Optional<String> emptyOptional = Optional.empty();

3.4 get

如果我们创建的Optional对象中有值存在则返回此值，如果没有值存在，则会抛出
NoSuchElementException异常。小demo如下：

Optional<String> stringOptional = Optional.of("张三");
System.out.println(stringOptional.get());

Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.get());

3.5 orElse

如果创建的Optional中有值存在，则返回此值，否则返回一个默认值

Optional<String> stringOptional = Optional.of("张三");
System.out.println(stringOptional.orElse("zhangsan"));

Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.orElse("李四"));

3.6 orElseGet

如果创建的Optional中有值存在，则返回此值，否则返回一个由Supplier接口生成的值

Optional<String> stringOptional = Optional.of("张三");
System.out.println(stringOptional.orElseGet(() -> "zhangsan"));

Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.orElseGet(() -> "orElseGet"));

3.7 orElseThrow

如果创建的Optional中有值存在，则返回此值，否则抛出一个由指定的Supplier接口生成的异常

Optional<String> stringOptional = Optional.of("张三");
System.out.println(stringOptional.orElseThrow(CustomException::new));

Optional<String> emptyOptional = Optional.empty();
System.out.println(emptyOptional.orElseThrow(CustomException::new));

private static class CustomException extends RuntimeException {
   private static final long serialVersionUID = -4399699891687593264L;

   public CustomException() {
       super("自定义异常");
   }

   public CustomException(String message) {
      super(message);
   }
  }

3.8 filter

如果创建的Optional中的值满足filter中的条件，则返回包含该值的Optional对象，否则返回一个空的Optional对象

Optional<String> stringOptional = Optional.of("zhangsan");
System.out.println(stringOptional.filter(e -> e.length() > 5).orElse("王五"));
stringOptional = Optional.empty();
System.out.println(stringOptional.filter(e -> e.length() > 5).orElse("lisi"));

注意Optional中的filter方法和Stream中的filter方法是有点不一样的，Stream中的filter方法是对一堆元素进
行过滤，而Optional中的filter方法只是对一个元素进行过滤，可以把Optional看成是最多只包含一个元素
的Stream。

3.9 map

如果创建的Optional中的值存在，对该值执行提供的Function函数调用

//map方法执行传入的lambda表达式参数对Optional实例的值进行修改,修改后的返回值仍然是一个Optional对象
Optional<String> stringOptional = Optional.of("zhangsan");
System.out.println(stringOptional.map(e -> e.toUpperCase()).orElse("失败"));

stringOptional = Optional.empty();
System.out.println(stringOptional.map(e -> e.toUpperCase()).orElse("失败"));

3.10 flagMap

如果创建的Optional中的值存在，就对该值执行提供的Function函数调用，返回一个Optional类型的值，否
则就返回一个空的Optional对象.flatMap与map（Funtion）方法类似，区别在于flatMap中的mapper返回
值必须是Optional，map方法的mapping函数返回值可以是任何类型T。调用结束时，flatMap不会对结果
用Optional封装。

//map方法中的lambda表达式返回值可以是任意类型，在map函数返回之前会包装为Optional。 
//但flatMap方法中的lambda表达式返回值必须是Optionl实例
Optional<String> stringOptional = Optional.of("zhangsan");
System.out.println(stringOptional.flatMap(e -> Optional.of("lisi")).orElse("失败"));

stringOptional = Optional.empty();
System.out.println(stringOptional.flatMap(e -> Optional.empty()).orElse("失败"));

3.11 ifPresent

//ifPresent方法的参数是一个Consumer的实现类，Consumer类包含一个抽象方法，该抽象方法对传入的值进行处理，只处理没有返回值。
Optional<String> stringOptional = Optional.of("zhangsan");
stringOptional.ifPresent(e-> System.out.println("我被处理了。。。"+e));

4.代码重构

4.1 重构前

参考文章
参考文章2

if (staff != null) {
    Department department = staff.getDepartment();
    if (department != null) {
        Company company = department.getCompany();
        if (company != null) {
            return company.getName();
        }
    }
}
return "Unknown";

4.2 重构之后

首先我们需要将 Staff ，Department 修改 getter 方法返回结果类型改成 Optional

public class Staff {
    private Department department;
    public Optional<Department> getDepartment() {
        return Optional.ofNullable(department);
    }
    ...
}
public class Department {

    private Company company;
    public Optional<Company> getCompany() {
        return Optional.ofNullable(company);
    }
    ...
}

public class Company {
    private String name;
    public String getName() {
        return name;
    }
    ...
}

Optional<Staff> staffOpt =...;
staffOpt
        .flatMap(Staff::getDepartment)
        .flatMap(Department::getCompany)
        .map(Company::getName)
        .orElse("Unknown");