Java 8备忘单中的可选

Java 8 java.util.Optional<T>是scala.Option[T]和Data.Maybe在Haskell中的较差表亲。但这并不意味着它没有用。如果您不熟悉此概念，请将Optional想象为可能包含或不包含某些值的容器。就像Java中的所有引用都可以指向某个对象或为null ， Option可以包含一些（非null！）引用或为空。

Aridalsvannet

事实证明，在Optional和可空引用之间进行类比是非常明智的。 Optional是在Java 8中引入的，因此很显然，它在整个标准Java库中都没有使用-永远不会出于向后兼容的原因。但我建议您至少尝试一下，并在有可空引用的情况下使用它。在编译时，将静态检查Optional而不是纯null ，并且它更具信息性，因为它清楚地表明给定变量可能存在或不存在。当然，这需要一定的纪律–永远不要再将null分配给任何变量。

选择（也许）模式的用法引起很大争议，我将不参与讨论。取而代之的是，我向您展示了null几个用例，以及如何将它们改型为Optional<T> 。在以下示例中，使用了给定的变量和类型：

public void print(String s) {System.out.println(s);
}String x = //...
Optional<String> opt = //...

x是一个可能为null的String， opt永远不会为null ，但可能包含或可能不包含某个值（ present或empty ）。创建Optional方法很少：

opt = Optional.of(notNull);opt = Optional.ofNullable(mayBeNull);opt = Optional.empty();

在第一种情况下， Optional 必须不包含null值，并且如果传递null则将引发异常。 ofNullable()将返回空值或存在（设置） Optional 。 empty(总是返回空Optional ，对应于null 。这是一个单例，因为Optional<T>是不可变的。

乏味的if语句：

if (x != null) {print(x);
}

可以用高阶函数ifPresent()代替：

opt.ifPresent(x -> print(x));
opt.ifPresent(this::print);

当lambda参数（ String x ）与函数形式参数匹配时，可以使用后一种语法（方法参考）。

有时，您不仅要在设置引用时还希望在满足某些条件时执行某些操作：

if (x != null && x.contains("ab")) {print(x);
}

这可以替换Optional.filter()轮流本（套） Optional清空Optional如果底层值不满足给定的谓词。如果输入Optional为空，则按原样返回：

opt.filter(x -> x.contains("ab")).ifPresent(this::print);

这等效于更必要的：

if(opt.isPresent() && opt.get().contains("ab")) {print(opt.get());
}

通常，您需要对某个值应用一些转换，但前提是该值必须不为null （避免使用NullPointerException ）：

if (x != null) {String t = x.trim();if (t.length() > 1) {print(t);}
}

这可以使用map()以更具声明性的方式完成：

opt.map(String::trim).filter(t -> t.length() > 1).ifPresent(this::print);

这变得棘手。 Optional.map()将给定函数应用于Optional内部的值，但Optional是存在Optional 。否则什么也不会发生，并返回empty() 。请记住，转换是类型安全的–在此处查看泛型：

Optional<String>  opt = //...
Optional<Integer> len = opt.map(String::length);

如果存在Optional<String>则也存在Optional<Integer> len ，包装String长度。但是，如果opt为空，则在它上面的map()除了更改泛型类型之外什么都不做。

在某些时候，您可能希望解开Optional并获得内部的真实价值。但是，如果Optional为空，则无法执行此操作。这是Java 8之前的处理此类情况的方法：

int len = (x != null)? x.length() : -1;

使用Optional我们可以说：

int len = opt.map(String::length).orElse(-1);

如果计算默认值缓慢，昂贵或有副作用，还有一个版本可以接受Supplier<T> ：

int len = opt.map(String::length).orElseGet(() -> slowDefault());     //orElseGet(this::slowDefault)

想象一下，您有一个不接受null但可能会产生一个null的函数：

public String findSimilar(@NotNull String s) //...

使用它有点麻烦：

String similarOrNull = x != null? findSimilar(x) : null;

使用Optional可以更轻松一些：

Optional<String> similar = opt.map(this::findSimilar);

如果我们的map()函数返回null ，则map()的结果为空Optional 。否则，这是用（present） Optional包装的所述函数的结果。到目前为止很好，但是如果我们有Optional为什么为什么我们返回可null值呢？

public Optional<String> tryFindSimilar(String s)  //...

我们的意图很明确，但是使用map()无法产生正确的类型。相反，我们必须使用flatMap() ：

Optional<Optional<String>> bad = opt.map(this::tryFindSimilar);
Optional<String> similar =       opt.flatMap(this::tryFindSimilar);

您看到双重Optional<Optional<...>>吗？绝对不是我们想要的。如果您正在映射返回Optional的函数，请改用flatMap 。这是此功能的简化实现：

public <U> Optional<U> flatMap(Function<T, Optional<U>> mapper) {if (!isPresent())return empty();else {return mapper.apply(value);}
}

如果值不可用，通常我们会抛出异常：

public char firstChar(String s) {if (s != null && !s.isEmpty())return s.charAt(0);elsethrow new IllegalArgumentException();
}

整个方法可以替换为以下成语：

opt.filter(s -> !s.isEmpty()).map(s -> s.charAt(0)).orElseThrow(IllegalArgumentException::new);

我们不希望事先创建异常的实例，因为创建异常的成本很高。

更大的例子

假设我们有一个Person的Address具有有效的validFrom日期。所有这些都可以为null 。我们想知道是否设置了validFrom以及过去：

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

相当丑陋和防御性。或者，但仍然很丑陋：

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

现在想象所有这些（ person ， getAddress() ， getValidFrom() ）是适当类型的Optional ，清楚地表明它们可能未设置：

class Person {private final Optional<Address> address;public Optional<Address> getAddress() {return address;}//...
}class Address {private final Optional<Instant> validFrom;public Optional<Instant> getValidFrom() {return validFrom;}//...
}

突然，计算变得更加简化：

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

它更具可读性吗？很难说。但是至少当始终使用Optional时，不可能产生NullPointerException 。

将

有时我想将Optional视为具有0或1个元素的集合¹ 。这可以使对map()和flatMap()理解更加容易。不幸的是， Optional没有toList()方法，但是很容易实现：

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

或更不习惯：

public static <T> List<T> toList(Optional<T> option) {if (option.isPresent())return Collections.singletonList(option.get());elsereturn Collections.emptyList();
}

但是为什么将自己限制为List<T>呢？ Set<T>和其他集合呢？ Java 8已经通过为Stream引入的Collectors API抽象创建任意集合。该API令人毛骨悚然，但可以理解：

public static <R, A, T> R collect(Optional<T> option, Collector<? super T, A, R> collector) {final A container = collector.supplier().get();option.ifPresent(v -> collector.accumulator().accept(container, v));return collector.finisher().apply(container);
}

我们现在可以说：

import static java.util.stream.Collectors.*;List<String> list = collect(opt, toList());
Set<String>  set  = collect(opt, toSet());

摘要

在Scala中， Optional<T>功能不如Option[T]强大（但至少不允许包装null ）。该API不如null那么简单，而且速度可能慢得多。但是，始终使用Optional的编译时检查的好处以及可读性和文档价值大大超过了缺点。此外，它可能会取代番石榴中几乎相同的com.google.common.base.Optional<T>

^{1 –从理论上讲，也许抽象和序列抽象都是单子，这就是为什么它们共享某些功能的原因}

参考：来自Java和社区博客的JCG合作伙伴 Tomasz Nurkiewicz提供的Java 8备忘单中的可选内容。