这两种方法有什么区别:Optional.flatMap()
和Optional.map()
?
一个例子将不胜感激。
Stream#flatMap
和之间进行一对一的对应Optional#flatMap
。
这两种方法有什么区别:Optional.flatMap()
和Optional.map()
?
一个例子将不胜感激。
Stream#flatMap
和之间进行一对一的对应Optional#flatMap
。
Answers:
使用map
如果函数返回的对象,你需要或者flatMap
如果该函数返回的Optional
。例如:
public static void main(String[] args) {
Optional<String> s = Optional.of("input");
System.out.println(s.map(Test::getOutput));
System.out.println(s.flatMap(Test::getOutputOpt));
}
static String getOutput(String input) {
return input == null ? null : "output for " + input;
}
static Optional<String> getOutputOpt(String input) {
return input == null ? Optional.empty() : Optional.of("output for " + input);
}
两个打印语句都打印相同的内容。
[flat]Map
使用input == null
?调用映射函数?我的理解是,Optional
如果缺少分切符-[JavaDoc](docs.oracle.com/javase/8/docs/api/java/util/…)似乎可以支持这一点-“ 如果存在值,则应用.. 。 ”。
Optional.of(null)
是一个Exception
。Optional.ofNullable(null) == Optional.empty()
。
它们都具有从可选类型到某种功能的功能。
map()
将函数“ 按原样 ”应用到您具有的可选组件上:
if (optional.isEmpty()) return Optional.empty();
else return Optional.of(f(optional.get()));
如果您的函数是的函数,会发生什么T -> Optional<U>
?
您的结果现在是Optional<Optional<U>>
!
就是这样flatMap()
:如果您的函数已经返回Optional
,flatMap()
则会更聪明,并且不会对其进行二次包装,而返回Optional<U>
。
它是两个功能性习语的组成:map
和flatten
。
注意:-以下是地图和平面地图功能的说明,否则Optional主要设计为仅用作返回类型。
您可能已经知道Optional是一种可能包含或不包含单个对象的容器,因此可以在预期空值的任何地方使用它(正确使用Optional可能不会看到NPE)。例如,如果您有一个期望一个Person对象可能为空的方法,那么您可能想要编写如下方法:
void doSome(Optional<Person> person){
/*and here you want to retrieve some property phone out of person
you may write something like this:
*/
Optional<String> phone = person.map((p)->p.getPhone());
phone.ifPresent((ph)->dial(ph));
}
class Person{
private String phone;
//setter, getters
}
在这里,您返回了一个String类型,该类型将自动包装为Optional类型。
如果人员分类如下所示,即电话也是可选的
class Person{
private Optional<String> phone;
//setter,getter
}
在这种情况下,调用map函数会将返回的值包装在Optional中,并产生如下结果:
Optional<Optional<String>>
//And you may want Optional<String> instead, here comes flatMap
void doSome(Optional<Person> person){
Optional<String> phone = person.flatMap((p)->p.getPhone());
phone.ifPresent((ph)->dial(ph));
}
PS; 除非没有isPresent()对其进行检查,否则切勿在Optional上调用get方法(如果需要),除非没有NullPointerExceptions无法生存。
Person
不当Optional
。Optional
像这样在成员上使用API的意图是违反的-请参阅mail.openjdk.java.net/pipermail/jdk8-dev/2013-September/…–
帮我看看这两个函数的源代码。
地图 -包装结果在可选。
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Optional.ofNullable(mapper.apply(value)); //<--- wraps in an optional
}
}
flatMap-返回“原始”对象
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Objects.requireNonNull(mapper.apply(value)); //<--- returns 'raw' object
}
}
flatMap
“返回原始对象” 是什么意思?flatMap
还会在中返回映射的对象“包装” Optional
。区别在于,在的情况下flatMap
,mapper函数将映射的对象包装在中,Optional
而map
本身将对象包装在中Optional
。
Optional.map()
:接受每个元素,如果值存在,则将其传递给函数:
Optional<T> optionalValue = ...;
Optional<Boolean> added = optionalValue.map(results::add);
现在添加的值是以下三个值之一:true
或false
包装到Optional(如果optionalValue
存在)中,或者包装为空的Optional。
如果您不需要处理结果ifPresent()
,则可以简单地使用,它没有返回值:
optionalValue.ifPresent(results::add);
Optional.flatMap()
:工作原理与相同的流方法相似。展平流。不同之处在于,如果显示值,则将其应用于功能。否则,将返回一个空的可选。
您可以使用它来构成可选的值函数调用。
假设我们有方法:
public static Optional<Double> inverse(Double x) {
return x == 0 ? Optional.empty() : Optional.of(1 / x);
}
public static Optional<Double> squareRoot(Double x) {
return x < 0 ? Optional.empty() : Optional.of(Math.sqrt(x));
}
然后,您可以计算逆的平方根,例如:
Optional<Double> result = inverse(-4.0).flatMap(MyMath::squareRoot);
或者,如果您愿意:
Optional<Double> result = Optional.of(-4.0).flatMap(MyMath::inverse).flatMap(MyMath::squareRoot);
如果inverse()
或squareRoot()
返回Optional.empty()
,则结果为空。
Optional<Double>
类型作为返回类型。
好的。你只有当你面对嵌套选配需要使用“flatMap”。这是例子。
public class Person {
private Optional<Car> optionalCar;
public Optional<Car> getOptionalCar() {
return optionalCar;
}
}
public class Car {
private Optional<Insurance> optionalInsurance;
public Optional<Insurance> getOptionalInsurance() {
return optionalInsurance;
}
}
public class Insurance {
private String name;
public String getName() {
return name;
}
}
public class Test {
// map cannot deal with nested Optionals
public Optional<String> getCarInsuranceName(Person person) {
return person.getOptionalCar()
.map(Car::getOptionalInsurance) // ① leads to a Optional<Optional<Insurance>
.map(Insurance::getName); // ②
}
}
与Stream一样,Optional#map将返回一个由Optional包装的值。这就是为什么我们得到一个嵌套的Optional-的原因Optional<Optional<Insurance>
。在②,我们想将其映射为保险实例,这就是悲剧发生的方式。根是嵌套的Optionals。如果我们能够获得核心价值,而不管外壳如何,那么我们就完成它。这就是flatMap所做的。
public Optional<String> getCarInsuranceName(Person person) {
return person.getOptionalCar()
.flatMap(Car::getOptionalInsurance)
.map(Insurance::getName);
}
最后,如果您想系统地学习Java8 ,我就向您推荐Java 8 In Action。