Java8 Optional用法和最佳实践

根据Oracle文档，Optional是一个容器对象，可以包含也可以不包含非null值。Optional在Java 8中引入，目的是解决  NullPointerExceptions的问题。本质上，Optional是一个包装器类，其中包含对其他对象的引用。在这种情况下，对象只是指向内存位置的指针，并且也可以指向任何内容。从其它角度看，Optional提供一种类型级解决方案来表示可选值而不是空引用。

## 在Optional之前

在Java 8之前，程序员将返回null而不是Optional。这种方法有一些缺点。一种是没有明确的方法来表示null可能是一个特殊值。如果我们要确保不会出现空指针异常，则需要对每个引用进行显式的空检查。

另外还有一些开发人员喜欢通过非空检查来实现业务逻辑，空对象不应该用来决定系统的行为，它们是意外的Exceptional值，应当被看成是错误，而不是业务逻辑状态。

当我们一个方法返回List集合时，应该总是返回一个空的List，而不是Null，这就允许调用者能够遍历它而不必检查Null，否则就抛出NPE。

```

private void getCode( User user){

if (user != null) {

Address address = user.getAddress();

if (address != null) {

Country country = address.getCountry();

if (country != null) {

String code = country.getCode();

if (code != null) {

code = code.toUpperCase();

}

}

}

}

}

```

## Optional

### 构造Optional的三种方式

```

public static<T> Optional<T> empty() {

Optional<T> t = (Optional<T>) EMPTY;

return t;

}

public static <T> Optional<T> of(T value) {

return new Optional<>(value);

}

public static <T> Optional<T> ofNullable(T value) {

return value == null ? empty() : of(value);

}

```

### 创建一个Optional类

#### 返回一个空的Optional实例

```

// Creating an empty optional

Optional<String> empty = Optional.empty();

```

在返回一个空的{Optional}实例时，Optional的值不存在。不过，这样做可能很有诱惑力，如果对象为空，请避免与Option.empty()返回的实例的{==}比较 。因为不能保证它是一个单例，反之，应该使用isPresent()。

#### 返回特定的非空值Optional

```

// Creating an optional using of

String name = "java";

Optional<String> opt = Optional.of(name);

```

静态方法需要一个非null参数；否则，将引发空指针异常。因此，如果我们不知道参数是否为null，那就是我们使用 ofNullable的时候，下面将对此进行介绍。

#### 返回描述指定值的Optional，如果非空，则返回空值

```

// Possible null value

Optional<String> optional = Optional.ofNullable(name());

private String name(){

String name = "Java";

return (name.length() > 5) ? name : null;

}

```

### 常用API

#### ifPresent()

如果存在值，则返回true；反之，返回false。如果所包含的对象不为null，则返回true，反之返回false。通常在对对象执行任何其他操作之前，先在Optional上调用此方法。

```

Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

Optional<String> longest = names

.filter(name -> name.startsWith("L"))

.findFirst();

longest.ifPresent(name -> {

String s = name.toUpperCase();

System.out.println("The longest name is "+ s);

});

//The longest name is LAMURUDU

```

这里ifPresent() 是将一个Lambda表达式作为输入，T值如果不为空将传入这个lambda。那么这个lambda将不为空的单词转为大写输出显示。在前面names单词流寻找结果中，有可能找不到开始字母为L的单词，返回为空，也可能找到不为空，这两种情况都传入lambda中，无需我们打开盒子自己编写代码来判断，它自动帮助我们完成了，无需人工干预。

#### map()

使用Optional<T>的map方法能够返回另外一个Optional

```

Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

Optional<String> longest = names

.filter(name -> name.startsWith("L"))

.findFirst();

Optional<String> lNameInCaps = longest.map(String::toUpperCase);

lNameInCaps.ifPresent(name -> {

System.out.println("The name is "+ name);

});

//The name is LAMURUDU

```

#### orElse()

返回值（如果存在）；反之，返回其他。

```

Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

Optional<String> longest = names

.filter(name -> name.startsWith("Q"))

.findFirst();

String alternate = longest.orElse("Nimrod");

System.out.println(alternate);

//Nimrod

```

#### orElseGet()

返回值（如果存在）；否则，调用other并返回该调用的结果。

该orElseGet() 方法类似于 orElse()。但是，如果没有Optional值，则不采用返回值，而是采用供应商功能接口，该接口将被调用并返回调用的值。

```

Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

Optional<String> longest = names

.filter(name -> name.startsWith("Q"))

.findFirst();

String alternate = longest.orElseGet(() -> {

return "Nimrod";

});

System.out.println(alternate);

//Nimrod

```

#### orElseThrow()

orElseThrow()是在当遭遇Null时，决定抛出哪个Exception时使用

```

Stream<String> names = Stream.of("Lamurudu", "Okanbi", "Oduduwa");

Optional<String> longest = names

.filter(name -> name.startsWith("Q"))

.findFirst();

longest.orElseThrow(NoSuchElementStartingWithQException::new);

```

### orElse() 和orElseGet()之间有什么区别

我们可能考虑的问题是：何时使用orElse和何时使用orElseGet？看起来可以使用orElseGet的时候，使用orElse也可以代替（因为Supplier接口没有入参），而且使用orElseGet还需要将计算过程额外包装成一个 lambda 表达式。

一个关键的点是，使用Supplier能够做到懒计算，即使用orElseGet时。它的好处是，只有在需要的时候才会计算结果。具体到我们的场景，使用orElse的时候，每次它都会执行计算结果的过程，而对于orElseGet，只有Optional中的值为空时，它才会计算备选结果。这样做的好处是可以避免提前计算结果的风险。

```

class User {

// 中文名

private String chineseName;

// 英文名

private EnglishName englishName;

}

class EnglishName {

// 全名

private String fullName;

// 简写

private String shortName;

}

```

假如我们现在有User类，用户注册账号时，需要提供自己的中文名或英文名，或都提供，我们抽象出一个EnglishName类，它包含英文名的全名和简写（因为有的英文名确实太长了）。现在，我们希望有一个User#getName()方法，它可以像下面这样实现：

```

class User {

// ... 之前的内容

public String getName1() {

return Optional.ofNullable(chineseName)

.orElse(englishName.getShortName());

}

public String getName2() {

return Optional.ofNullable(chineseName)

.orElseGet(() -> englishName.getShortName());

}

}

```

两个版本，分别使用orElse和orElseGet。现在可以看出getName1()方法有什么风险了吗？它会出现空指针异常吗？

答案是：是的。当用户只提供了中文名时，此时englishName属性是null，但是在orElse中，englishName.getShortName()总是会执行。而在getName2()中，这个风险却没有。