Java 8 Optional类深度解析（转）

　　现在我来看看filter的各种用法，下面的示例介绍了满足限定条件和不满足两种情况：

//filter方法检查给定的Option值是否满足某些条件。
//如果满足则返回同一个Option实例，否则返回空Optional。
Optional longName = name.filter((value) -> value.length() > 6);
System.out.println(longName.orElse("The name is less than 6 characters"));//输出Sanaulla
 
//另一个例子是Optional值不满足filter指定的条件。
Optional anotherName = Optional.of("Sana");
Optional shortName = anotherName.filter((value) -> value.length() > 6);
System.out.println(shortName.orElse("The name is less than 6 characters"));//输出：name长度不足6字符

以上，我们介绍了Optional类的各个方法。下面通过一个完整的示例对用法集中展示：

public class OptionalDemo {

　　public static void main(String[] args) {
　　　　//创建Optional实例，也可以通过方法返回值得到。
　　　　Optional name = Optional.of("Sanaulla");
 
　　　　//创建没有值的Optional实例，例如值为'null'
　　　　Optional empty = Optional.ofNullable(null);
 
　　　　//isPresent方法用来检查Optional实例是否有值。
　　　　if (name.isPresent()) {
　　　　　　//调用get()返回Optional值。
　　　　　　System.out.println(name.get());
　　　　}
 
　　　　try {
　　　　　　//在Optional实例上调用get()抛出NoSuchElementException。
　　　　　　System.out.println(empty.get());
　　　　} catch (NoSuchElementException ex) {
　　　　　　System.out.println(ex.getMessage());
　　　　}
 
　　　　//ifPresent方法接受lambda表达式参数。
　　　　//如果Optional值不为空，lambda表达式会处理并在其上执行操作。
　　　　name.ifPresent((value) -> {
　　　　　　System.out.println("The length of the value is: " + value.length());
　　　　});
 
　　　　//如果有值orElse方法会返回Optional实例，否则返回传入的错误信息。
　　　　System.out.println(empty.orElse("There is no value present!"));
　　　　System.out.println(name.orElse("There is some value!"));
 
　　　　//orElseGet与orElse类似，区别在于传入的默认值。
　　　　//orElseGet接受lambda表达式生成默认值。
　　　　System.out.println(empty.orElseGet(() -> "Default Value"));
　　　　System.out.println(name.orElseGet(() -> "Default Value"));
 
　　　　try {
　　　　　　//orElseThrow与orElse方法类似，区别在于返回值。
　　　　　　//orElseThrow抛出由传入的lambda表达式/方法生成异常。
　　　　　　empty.orElseThrow(ValueAbsentException::new);
　　　　} catch (Throwable ex) {
　　　　　　System.out.println(ex.getMessage());
　　　　}

　　　　//map方法通过传入的lambda表达式修改Optonal实例默认值。 
　　　　//lambda表达式返回值会包装为Optional实例。
　　　　Optional upperName = name.map((value) -> value.toUpperCase());
　　　　System.out.println(upperName.orElse("No value found"));

　　　　//flatMap与map（Funtion）非常相似，区别在于lambda表达式的返回值。
　　　　//map方法的lambda表达式返回值可以是任何类型，但是返回值会包装成Optional实例。
　　　　//但是flatMap方法的lambda返回值总是Optional类型。
　　　　upperName = name.flatMap((value) -> Optional.of(value.toUpperCase()));
　　　　System.out.println(upperName.orElse("No value found"));
 
　　　　//filter方法检查Optiona值是否满足给定条件。
　　　　//如果满足返回Optional实例值，否则返回空Optional。
　　　　Optional longName = name.filter((value) -> value.length() > 6);
　　　　System.out.println(longName.orElse("The name is less than 6 characters"));
 
　　　　//另一个示例，Optional值不满足给定条件。
　　　　Optional anotherName = Optional.of("Sana");
　　　　Optional shortName = anotherName.filter((value) -> value.length() > 6);
　　　　System.out.println(shortName.orElse("The name is less than 6 characters"));
　　}
 }

　　上述代码输出如下：

Sanaulla
No value present
The length of the value is: 8
There is no value present!
Sanaulla
Default Value
Sanaulla
No value present in the Optional instance
SANAULLA
SANAULLA
Sanaulla
The name is less than 6 characters

实例展示

实例一：

　　假如有一个Person 对象，它有一个Address 属性，而Address属性还嵌套一个validFrom的日期。所有的值都可能是null。好了，现在我们来判断一下Person 的这些属性是否是Valid的。

private boolean validAddress(NullPerson person) {
　　if (person != null) {
　　　　if (person.getAddress() != null) {
　　　　　　final Instant validFrom = person.getAddress().getValidFrom();
　　　　　　return validFrom != null && validFrom.isBefore(now());
　　　　} else
　　　　　　return false;
　　} else
　　　　return false;
}

　　或者也可以这么写：

return person != null &&
    person.getAddress() != null &&
    person.getAddress().getValidFrom() != null &&
    person.getAddress().getValidFrom().isBefore(now());

　　总之 都不是很好看。但如果这些属性都是Optional，那么看起来会稍微舒服一点。

class Person {

　　private final Optional
 address;

　　public Optional
 getAddress() {
　　　　return address;
　　}
 
　　//...
}

class Address {
　　private final Optional validFrom;

　　public Optional getValidFrom() {
　　　　return validFrom;
　　}

　　//...
}

　　以下代码就实现了一样的判断：

return person.flatMap(Person::getAddress).flatMap(Address::getValidFrom).filter(x -> x.before(now())).isPresent();

　　使用Optional以后，NullPointerException 就从此消失了。

将一个Optional转为List或者Set

　　Optional是一个集合，虽然里面只有0或者1个元素，但它一样是一个集合。如果要转为List或者Set，一般的写法可以是：

public static  List toList(Optional option) {
　　return option.map(Collections::singletonList).orElse(Collections.emptyList());
}

　　或者更传统的写法：

public static  List toList(Optional option) {
　　if (option.isPresent())
　　　　return Collections.singletonList(option.get());
　　else
　　　　return Collections.emptyList();
}

　　但是在java8里，其实只需要这么写：

import static java.util.stream.Collectors.*;
//转为List
List list = collect(opt, toList());
//转为Set
Set  set  = collect(opt, toSet());

实例二：

　　一个man可能会有一个女神，如果有女神则返回女神姓名，没有返回一个默认name。

　　传统做法：

public String getGodnessName(Man man) {
　　if (man != null) {
　　　　Godness godness = man.getGodness();
　　　　if (godness !=null) {
　　　　　　return godness.getName();

　　　　}
　　}
　　return "小离";
}

public void test5() {
　　Man man = new Man();
　　String godnessName = getGodnessName(man);
　　System.out.println(godnessName);//打印结果小离
}

　　用Optional类来处理(代码清爽了一些)

public String getGodnessName2(Optional man) {
　　return man.orElse(new NewMan())//如果man是null则新创建一个对象
　　　　　　.getGodness()
　　　　　　.orElse(new Godness("小离"))//如果man没有女神则设置一个默认女神的名字
　　　　　　.getName();
}

public void test5() {
　　Optional godness = Optional.ofNullable(new Godness("小妹"));
　　Optional op = Optional.ofNullable(new NewMan(godness));
　　String str = getGodnessName2(op);
　　System.out.println(str);//打印结果小妹
}

文章转于：https://www.cnblogs.com/xingzc/p/5778090.html