Java Optional API

一位智者说过,没有处理过空指针异常就不算一个真正的 Java 程序员。这当然是开玩笑,但是空指针异常确实是很多程序出错的源头。
于是,在 Java 8 引入了 java.util.Optional
,Optional 用来代表一种 可能有可能没有
数据,可以用来缓解空指针异常的问题。

简单地说,Optional 用来避免这种代码

String version = "UNKNOWN";
if(computer != null){
  Soundcard soundcard = computer.getSoundcard();
  if(soundcard != null){
    USB usb = soundcard.getUSB();
    if(usb != null){
      version = usb.getVersion();
    }
  }
}
复制代码

如果用 Optional 表示呢?大概是这样:

String version = computer.flatMap(Computer::getSoundcard)
                         .flatMap(Soundcard::getUSB)
                         .map(USB::getVersion)
                         .orElse("UNKNOWN");
复制代码

实际上,Optional 即函数式编程中的 Maybe。

以下示例在OptionalTest.java 中。

创建

创建 Optional 有三种方式,分别是 empty、 of 和 ofNullable。

empty

empty
用来创建一个空的 Optional

@Test
public void create_optional_with_empty() {
    Optional<String> empty = Optional.empty();
    assertFalse(empty.isPresent());
}
复制代码

of

of
用来创建一个非空的 Optional:

@Test
public void create_optional_with_of() {
    Optional<String> java = Optional.of("Java");
    assertTrue(java.isPresent());
}
复制代码

但是参数不能为 null,否则会抛空指针异常:

@Test(expected = NullPointerException.class)
public void create_optional_with_of_with_null() {
    Optional.of(null);
}
复制代码

ofNullable

ofNullable
用来创建一个可能为空的 Optional:

@Test
public void create_optional_with_ofNullable() {
    Optional<String> java = Optional.ofNullable("Java");
    assertTrue(java.isPresent());

    Optional<Object> o = Optional.ofNullable(null);
    assertFalse(o.isPresent());
}
复制代码

检测值是否存在

可以使用 isPresent
isEmpty
判断 Optional 的值是否为空。

isPresent

如果 Optional 中值非 null,则返回 true,否则返回 false。

@Test
public void check_optional_with_isPresent() {
    Optional<String> java = Optional.ofNullable("java");
    Optional<Object> aNull = Optional.ofNullable(null);

    assertTrue(java.isPresent());
    assertFalse(aNull.isPresent());
}
复制代码

isEmpty

Java 11 开始可以使用 isEmpty

isEmpty
isPresent
相反,如果为 null 返回 true。

@Test
public void check_optional_with_isEmpty() {
    Optional<String> java = Optional.ofNullable("java");
    Optional<Object> aNull = Optional.ofNullable(null);

    assertFalse(java.isEmpty());
    assertTrue(aNull.isEmpty());
}
复制代码

条件动作

关于条件的动作有 ifPresent
orElse
orElseGet
orElseThrow
or
ifPresentOrElse
,它们执行与否取决于 Optional 的值是否为 null。

为了避免空指针异常,我们会经常写下面的代码:

if (name != null){
    System.out.println(name.length);
}
复制代码

Optional 使用一种函数式的方式来替代上面的写法。

ifPresent

ifPresent 接受一个 Consumer,在 Optional 值非 null 时调用,并接受 Optional 的值。

@Test
public void condition_action_ifPresent() {
    Optional<String> java = Optional.ofNullable("java");
    java.ifPresent((value) -> System.out.println("ifPresent accept " + value));

    Optional<Object> aNull = Optional.ofNullable(null);
    aNull.ifPresent(value -> System.out.println("this will never execute"));
}
复制代码

orElse

orElse 在 Optional 值为 null 时触发,它接受一个参数,作为 Optional 的默认值。

@Test
public void condition_action_orElse() {
    assertTrue(Optional.ofNullable("java").orElse("javascript").equals("java"));
    assertTrue(Optional.ofNullable(null).orElse("java").equals("java"));
}
复制代码

orElseGet

orElseGet 与 orElse 类似,但 orElseGet 接受的是一个 Supplier,Supplier 返回的值作为 Optional 的默认值。

@Test
public void condition_action_orElseGet() {
    assertTrue(Optional.ofNullable("java").orElseGet(() -> "javascript").equals("java"));
    assertTrue(Optional.ofNullable(null).orElseGet(() -> "java").equals("java"));
}
复制代码

orElse 和 orElseGet 的区别

orElse
orElseGet
的函数签名是不一样的,但如果想使用同样的函数的返回值来作为 Optional 的默认值,我们很可能会这么干:

public String getDefaultName() {
    System.out.println("You got a default name");
    return "default";
}
    
@Test
public void difference_between_orElse_and_orElseGet() {
    Optional<String> java = Optional.of("java");

    System.out.println("orElse:");
    assertEquals("java", java.orElse(getDefaultName()));
    System.out.println("orElseGet:");
    assertEquals("java", java.orElseGet(this::getDefaultName));
}
复制代码

若 java 是 null,则 orElse 和 orElseGet 没有什么不同,getDefaultName 方法都会执行并将返回值作为 Optional 的默认值。

当在上面的例子中,java 非 null,这时 orElse 的 getDefaultName 还是会执行,但 orElseGet 不会。输出:

orElse:
You got a default name
orElseGet:
复制代码

当 getDefaultName 中有副作用或耗时操作时需要注意。

orElseThrow

orElseThrow 与 orElse 一样也在当 Optional 值为 null 时触发,但与之不同的是会抛出指定的异常:

@Test(expected = IllegalArgumentException.class)
public void condition_action_orElseThrow() {
    Optional.ofNullable(null).orElseThrow(IllegalArgumentException::new);
}
复制代码

or

or 是 Java 9 中新增方法。与 orElseGet 很相似,or 也接受一个 Supplier,但 or 返回的是一个新的 Optional。

@Test
public void condition_or_optional() {
    Optional<String> java = Optional.of("java")
                                    .or(() -> Optional.of("javascript"));
    Optional<Object> java1 = Optional.empty()
                                     .or(() -> Optional.of("java"));
    assertEquals("java", java.get());
    assertEquals("java", java1.get());
}
复制代码

ifPresentOrElse

ifPresentOrElse 是 Java 9 中新增的方法。ifPresent 就如同命令式编程中的 if-else
,它接受两个参数,第一个为 Consumer,在 Optional 有值时调用,第二个为 Runnable,在无值时调用:

@Test
public void condition_ifPresentOrElse() {
    // value is java
    Optional.of("java")
            .ifPresentOrElse(value -> System.out.println("value is " + value), () -> System.out.println("ooops"));

    // ooops
    Optional.empty()
            .ifPresentOrElse(value -> System.out.println("value is " + value), () -> System.out.println("ooops"));
}
复制代码

获取值

Optional 提供了一个 get
方法获取值,但 get 方法只能在 Optional 有值时使用,否则会抛出 NoSuchElementException
异常:

@Test
public void get_optional_with_of() {
    Optional<String> java = Optional.of("Java");
    assertEquals("java", java.get());
}

@Test(expected = NoSuchElementException.class)
public void get_optional_with_of_with_null() {
    Optional.empty().get();
}
复制代码

验证值

filter
方法用来验证 Optional 的值是否符合条件,它接受一个 Predicate 作为参数。如果 Optional 的值为 null 或 Predicate 判断不通过,则返回 empty;否则返回该 Optional。

@Test
public void test_optional_by_filter() {
    Integer nullYear = null;
    Optional<Integer> integer = Optional.ofNullable(nullYear)
                                        .filter(value -> value == 2018);
    assertEquals(Optional.empty(), integer);

    Integer year = 2019;
    Optional<Integer> integer1 = Optional.ofNullable(year)
                                         .filter(value -> value == 2018);
    assertEquals(Optional.empty(), integer1);

    Optional<Integer> integer2 = Optional.ofNullable(year)
                                         .filter(value -> value == 2019);
    assertEquals("Optional[2019]", integer2.toString());
}
复制代码

filter 相对传统 if 而言省去了很多样板代码,如:

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

使用 Optional 实现同样的方法:

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

处理值

处理值的方式有 map 和 flatMap。

map

使用 map 可以对 Optional 中的值进行处理并返回。

@Test
public void map_optional() {
    Optional<String> java = Optional.of("java");
    String result = java.map(String::toUpperCase).orElse("");
    assertEquals("JAVA", result);
}
复制代码

flatMap

flatMap 与 map 的区别在于 map 处理值后会包装返回值,而 flatMap 不包装。

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public Optional<String> getName() {
        return Optional.ofNullable(name);
    }
}

@Test
public void flatMap_optional() {
    Person person = new Person("john");
    Optional<Person> personOptional = Optional.of(person);

    String byMap = personOptional.map(Person::getName)
                                 // 需要手动打开包装
                                 .orElse(Optional.empty())
                                 .orElse("");

    String byFlatMap = personOptional.flatMap(Person::getName)
                                     .orElse("");

    assertEquals("john", byMap);
    assertEquals("john", byFlatMap);
}
复制代码

流操作

在 Java 9 中,新增了 stream 方法,可以对 Optional 创建 stream,然后可以使用 stream 上的所有方法。

如果 Optional 为 empty,则创建一个 empty 的 stream。

@Test
public void treat_optional_as_stream() {
    List<String> collect = Optional.of("java")
                                   .stream()
                                   .map(value -> value.concat("script"))
                                   .collect(Collectors.toList());

    assertArrayEquals(new String[]{"javascript"}, collect.toArray());


    // empty optional
    Optional<String> value = Optional.empty();
    List<String> emptyStream = value.stream()
                                    .map(String::toUpperCase)
                                    .collect(Collectors.toList());

    assertEquals(0, emptyStream.size());
}
复制代码

所以使用 stram 也可以筛出非 null 的 Optional 的值:

@Test
public void filter_empty_by_stream() {
    List<Optional<String>> languages = List.of(Optional.of("java"), Optional.empty(), Optional.empty(), Optional.of("javascript"));
    List<String> collect = languages.stream()
                                    .flatMap(Optional::stream)
                                    .collect(Collectors.toList());

    assertArrayEquals(new String[]{"java", "javascript"}, collect.toArray());
}
复制代码

参考

  • Tired of Null Pointer Exceptions? Consider Using Java SE 8’s Optional!
  • Guide To Java 8 Optional
  • Java 9 Optional API Additions
  • Filtering a Stream of Optionals in Java

原文 

https://juejin.im/post/5dd210545188252a091e9af8

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Java Optional API

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址