java备忘录_Java 8备忘单中的可选-CSDN博客

java备忘录

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时才适用。否则什么也不会发生，并返回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);
    else
        throw 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());
        } else
            return false;
    } else
        return 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使用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());
    else
        return 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备忘单中的可选内容。