java备忘录
Java 8 java.util.Optional<T>
是scala.Option[T]
和Data.Maybe
在Haskell中的较差表亲。 但这并不意味着它没有用。 如果您不熟悉此概念,请将Optional
想象为可能包含或不包含某些值的容器。 就像Java中的所有引用都可以指向某个对象或为null
, Option
可以包含一些(非null!)引用或为空。
事实证明,在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个元素的集合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 –从理论上讲, 也许抽象和序列抽象都是单子 ,这就是为什么它们共享某些功能的原因
翻译自: https://www.javacodegeeks.com/2013/08/optional-in-java-8-cheat-sheet.html
java备忘录