Java8之Optional用法

原文地址:https://www.baeldung.com/java-optional  只是将其翻译一遍，加上些自己的理解，顺便总结一下

一 概览

     Optional是java.util包中的一部分，因此为了使用Optional，需要:

import java.util.Optional;

二 创建

2.1 调用empty API， 创建一个空的Optional对象：

@Test
public void whenCreatesEmptyOptional_thenCorrect() {
    Optional<String> empty = Optional.empty();
    assertFalse(empty.isPresent());
}

Ps: isPresent API 是用来检查Optional对象中是否有值。只有当我们创建了一个含有非空值的Optional时才返回true。在下一部分我们将介绍这个API。

2.2 使用staticAPI创建

@Test
public void givenNonNull_whenCreatesOptional_thenCorrect() {
    String name = "baeldung";
    Optional<String> opt = Optional.of(name);
    assertEquals("Optional[baeldung]", opt.toString());
}

然而，传递给of()的值不可以为空，否则会抛出空指针异常，如下:

@Test(expected = NullPointerException.class)
public void givenNull_whenThrowsErrorOnCreate_thenCorrect() {
    String name = null;
    Optional<String> opt = Optional.of(name);
}

有时我们需要传递一些空值，那我们可以使用下面这个API:

@Test
public void givenNonNull_whenCreatesNullable_thenCorrect() {
    String name = "baeldung";
    Optional<String> opt = Optional.ofNullable(name);
    assertEquals("Optional[baeldung]", opt.toString());
}

使用ofNullable API，则当传递进去一个空值时，不会抛出异常，而只是返回一个空的Optional对象，如同我们用Optional.empty API:

@Test
public void givenNull_whenCreatesNullable_thenCorrect() {
    String name = null;
    Optional<String> opt = Optional.ofNullable(name);
    assertEquals("Optional.empty", opt.toString());
}

三  使用isPresent API 检查值

我们可以使用这个API检查一个Optional对象中是否有值，只有值非空才返回true。

@Test
public void givenOptional_whenIsPresentWorks_thenCorrect() {
    Optional<String> opt = Optional.of("Baeldung");
    assertTrue(opt.isPresent());
 
    opt = Optional.ofNullable(null);
    assertFalse(opt.isPresent());
}

四 适当情况下使用isPresent API 

传统上，我们一般这样写来检查空值:

if(name != null){
    System.out.println(name.length);
}

问题在于，有时候我们会忘记了对空值进行检查，这时就可以使用这个API：

@Test
public void givenOptional_whenIfPresentWorks_thenCorrect() {
    Optional<String> opt = Optional.of("baeldung");
 
    opt.ifPresent(name -> System.out.println(name.length()));
}

五 orEse && orElseGet

5.1   orElse

这个API被用来检索Optional对象中的值，它被传入一个“默认参数‘。如果对象中存在一个值，则返回它，否则返回传入的“默认参数”，如下所示：

@Test
public void whenOrElseWorks_thenCorrect() {
    String nullName = null;
    String name = Optional.ofNullable(nullName).orElse("john");
    assertEquals("john", name);
}

5.2 orElseGet

与orElsel类似，但是这个函数不接收一个“默认参数”，而是一个函数接口，如下例所示：

@Test
public void whenOrElseGetWorks_thenCorrect() {
    String nullName = null;
    String name = Optional.ofNullable(nullName).orElseGet(() -> "john");
    assertEquals("john", name);
}

5.3 两者区别

 要想理解这二者，首先让我们创建一个无参且返回定值的方法:

public String getMyDefault() {
    System.out.println("Getting Default Value");
    return "Default Value";
}

接下来，进行两个测试看看它们有什么区别:

@Test
public void whenOrElseGetAndOrElseOverlap_thenCorrect() {
    String text;
 
    System.out.println("Using orElseGet:");
    String defaultText = 
      Optional.ofNullable(text).orElseGet(this::getMyDefault);
    assertEquals("Default Value", defaultText);
 
    System.out.println("Using orElse:");
    defaultText = Optional.ofNullable(text).orElse(getMyDefault());
    assertEquals("Default Value", defaultText);
}

在这里示例中，我们的Optional对象中包含的都是一个空值，让我们看看程序执行结果:

Using orElseGet:
Getting default value...
Using orElse:
Getting default value...

两个Optional对象中都不存在value，因此执行结果相同。

那么当Optional对象中值存在时又是怎样呢？

@Test
public void whenOrElseGetAndOrElseDiffer_thenCorrect() {
    String text = "Text present";
 
    System.out.println("Using orElseGet:");
    String defaultText 
      = Optional.ofNullable(text).orElseGet(this::getMyDefault);
    assertEquals("Text present", defaultText);
 
    System.out.println("Using orElse:");
    defaultText = Optional.ofNullable(text).orElse(getMyDefault());
    assertEquals("Text present", defaultText);
}

让我们看看执行结果:

Using orElseGet:
Using orElse:
Getting default value...

可以看到，当使用orElseGet去检索值时，getMyDefault并不执行，因为Optional中含有值，而使用orElse时则照常执行。所以可以看到，当值存在时，orElse相比于orElseGet，多创建了一个对象，可能从这个实例中你感受不到影响有多大，但考虑当getDefalut不仅仅是个简单函数，而是一个web service之类的，则多创建一个代价是比较大的。

六   orElseThrow

orElseThrow当遇到一个不存在的值的时候，并不返回一个默认值，而是抛出异常，如下所示:

@Test(expected = IllegalArgumentException.class)
public void whenOrElseThrowWorks_thenCorrect() {
    String nullName = null;
    String name = Optional.ofNullable(nullName).orElseThrow(
      IllegalArgumentException::new);
}

七  使用get()

@Test
public void givenOptional_whenGetsValue_thenCorrect() {
    Optional<String> opt = Optional.of("baeldung");
    String name = opt.get();
 
    assertEquals("baeldung", name);
}

使用get() API 也可以返回被包裹着的值。但是必须是值存在时，当值不存在时，它会抛出一个NoSuchElementException异常，如下所示:

@Test(expected = NoSuchElementException.class)
public void givenOptionalWithNull_whenGetThrowsException_thenCorrect() {
    Optional<String> opt = Optional.ofNullable(null);
    String name = opt.get();
}

因为这个方法与我们使用Optional的目的相违背，所以可以预见在不久将来它或许会被抛弃，建议还是使用其他的方法。

八   filter()

接收一个函数式接口，当符合接口时，则返回一个Optional对象，否则返回一个空的Optional对象。

@Test
public void whenOptionalFilterWorks_thenCorrect() {
    Integer year = 2016;
    Optional<Integer> yearOptional = Optional.of(year);
    boolean is2016 = yearOptional.filter(y -> y == 2016).isPresent();
    assertTrue(is2016);
    boolean is2017 = yearOptional.filter(y -> y == 2017).isPresent();
    assertFalse(is2017);
}

这个API作用一般就是拒绝掉不符合条件的，比如拒绝掉错误的电子邮箱。

让我们看下一个更有意义的例子，假如我们想买一个调制解调器，并且只关心它的价格:

public class Modem {
    private Double price;
 
    public Modem(Double price) {
        this.price = price;
    }
    //standard getters and setters
}

接下来，我们想要检查每一类调制解调器是否在我们可以承受的价格范围内，那我们在不使用Optional时该如何做呢？

public boolean priceIsInRange1(Modem modem) {
    boolean isInRange = false;
 
    if (modem != null && modem.getPrice() != null
      && (modem.getPrice() >= 10
        && modem.getPrice() <= 15)) {
 
        isInRange = true;
    }
    return isInRange;
}

我们竟然要写这么多code，尤其是if条件语句，然而对于这部分code最关键的其实是对价格范围的判断。

这是一个Test例子:

@Test
public void whenFiltersWithoutOptional_thenCorrect() {
    assertTrue(priceIsInRange1(new Modem(10.0)));
    assertFalse(priceIsInRange1(new Modem(9.9)));
    assertFalse(priceIsInRange1(new Modem(null)));
    assertFalse(priceIsInRange1(new Modem(15.5)));
    assertFalse(priceIsInRange1(null));
}

如果长时间不用，那么有可能会忘记对null进行检查，那么如果使用Optional，会怎么样呢？

public boolean priceIsInRange2(Modem modem2) {
     return Optional.ofNullable(modem2)
       .map(Modem::getPrice)
       .filter(p -> p >= 10)
       .filter(p -> p <= 15)
       .isPresent();
 }

map()仅仅是将一个值转换为另一个值，请谨记在心，这个操作并不会改变原来的值。

让我们仔细看看这段代码，首先，当我们传入一个null时，不会发生任何问题。其次，我们在这段code所写的唯一逻辑就如同此方法名所描述。

之前的那段code为了其固有的脆弱性，必须做更多，而现在不用了。

九   map()

在之前的例子中，我们使用filter()来接受/拒绝一个一个值，而使用map()我们可以将一个值转换为另一个值。

@Test
public void givenOptional_whenMapWorks_thenCorrect() {
    List<String> companyNames = Arrays.asList(
      "paypal", "oracle", "", "microsoft", "", "apple");
    Optional<List<String>> listOptional = Optional.of(companyNames);
 
    int size = listOptional
      .map(List::size)
      .orElse(0);
    assertEquals(6, size);
}

在这个例子中，我们使用一个List包含了一些字符串，然后再把这个List包裹起来，对其map()，我们这里是对这个List求它的size。

map()返回的结果也被包裹在一个Optional对象中，我们必须调用合适的方法来查看其中的值。

注意到filter()仅仅是对值进行一个检查并返回一个boolean(很奇怪，照前面所述不应返回一个Optional对象吗？)，而map()是使用现有的值进行计算，并且返回一个包裹着计算结果(映射结果)的Optional对象。

@Test
public void givenOptional_whenMapWorks_thenCorrect2() {
    String name = "baeldung";
    Optional<String> nameOptional = Optional.of(name);
 
    int len = nameOptional
     .map(String::length())
     .orElse(0);
    assertEquals(8, len);
}

将filter()与map()一起使用可以做一些很强力的事情。

假设我们现在要检查一个用户的密码，那么我们可以这样做:

@Test
public void givenOptional_whenMapWorksWithFilter_thenCorrect() {
    String password = " password ";
    Optional<String> passOpt = Optional.of(password);
    boolean correctPassword = passOpt.filter(
      pass -> pass.equals("password")).isPresent();
    assertFalse(correctPassword);
 
    correctPassword = passOpt
      .map(String::trim)
      .filter(pass -> pass.equals("password"))
      .isPresent();
    assertTrue(correctPassword);
}

注意到，如果不进行trim，则会返回false，这里我们可以使用map()进行trim。

十 flatmap()

有时我们可以使用flatmap()替换map()，二者不同之处在于，map()只有当值不被包裹时才进行转换，而flatmap()接受一个被包裹着的值并且在转换之前对其解包。

我们现在有一个Person类:

public class Person {
    private String name;
    private int age;
    private String password;
 
    public Optional<String> getName() {
        return Optional.ofNullable(name);
    }
 
    public Optional<Integer> getAge() {
        return Optional.ofNullable(age);
    }
 
    public Optional<String> getPassword() {
        return Optional.ofNullable(password);
    }
    // normal constructors and setters
}

我们可以像对待String一样将其包裹起来:

Person person = new Person("john", 26);
Optional<Person> personOptional = Optional.of(person);

注意当我们包裹一个Person对象时，它将包含一个嵌套的Optional例子:

@Test
public void givenOptional_whenFlatMapWorks_thenCorrect2() {
    Person person = new Person("john", 26);
    Optional<Person> personOptional = Optional.of(person);
 
    Optional<Optional<String>> nameOptionalWrapper  
      = personOptional.map(Person::getName);
    Optional<String> nameOptional  
      = nameOptionalWrapper.orElseThrow(IllegalArgumentException::new);
    String name1 = nameOptional.orElse("");
    assertEquals("john", name1);
 
    String name = personOptional
      .flatMap(Person::getName)
      .orElse("");
    assertEquals("john", name);
}

需要注意，方法getName返回的是一个Optional对象，而不是像trim那样。这样就生成了一个嵌套的Optional对象。

因此使用map，我们还需要再解包一次，而使用flatMap()就不需要了。

错误不当之处请指出，谢谢。