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);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使用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 –从理论上讲， 也许抽象和序列抽象都是单子 ，这就是为什么它们共享某些功能的原因}

翻译自: https://www.javacodegeeks.com/2013/08/optional-in-java-8-cheat-sheet.html

java备忘录