Java 8 Optional使用

一概览

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

import java.util.Optional;

二创建

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

@Test
public void whenCreatesEmptyOptional_thenCorrect() {
Optional 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 opt = Optional.of(name);
assertEquals("Optional[baeldung]", opt.toString());
}
复制代码
然而，传递给of()的值不可以为空，否则会抛出空指针异常，如下:

@Test(expected = NullPointerException.class)
public void givenNull_whenThrowsErrorOnCreate_thenCorrect() {
String name = null;
Optional opt = Optional.of(name);
}
有时我们需要传递一些空值，那我们可以使用下面这个API:

复制代码
@Test
public void givenNonNull_whenCreatesNullable_thenCorrect() {
String name = "baeldung";
Optional 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 opt = Optional.ofNullable(name);
assertEquals("Optional.empty", opt.toString());
}
复制代码

三使用isPresent API 检查值

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

复制代码
@Test
public void givenOptional_whenIsPresentWorks_thenCorrect() {
Optional 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 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 opt = Optional.of("baeldung");
String name = opt.get();

assertEquals("baeldung", name);

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

@Test(expected = NoSuchElementException.class)
public void givenOptionalWithNull_whenGetThrowsException_thenCorrect() {
Optional opt = Optional.ofNullable(null);
String name = opt.get();
}
因为这个方法与我们使用Optional的目的相违背，所以可以预见在不久将来它或许会被抛弃，建议还是使用其他的方法。

八 filter()

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

复制代码
@Test
public void whenOptionalFilterWorks_thenCorrect() {
Integer year = 2016;
Optional 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 companyNames = Arrays.asList(
"paypal", "oracle", "", "microsoft", "", "apple");
Optional> 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 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 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 getName() {
    return Optional.ofNullable(name);
}

public Optional getAge() {
    return Optional.ofNullable(age);
}

public Optional getPassword() {
    return Optional.ofNullable(password);
}
// normal constructors and setters

}
复制代码
我们可以像对待String一样将其包裹起来:

Person person = new Person("john", 26);
Optional personOptional = Optional.of(person);
注意当我们包裹一个Person对象时，它将包含一个嵌套的Optional例子:

复制代码
@Test
public void givenOptional_whenFlatMapWorks_thenCorrect2() {
Person person = new Person("john", 26);
Optional personOptional = Optional.of(person);

Optional> nameOptionalWrapper  
  = personOptional.map(Person::getName);
Optional 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()就不需要了

Java 8 Optional使用

你可能感兴趣的:(Java 8 Optional使用)