如果函数返回需要的对象，则使用map;如果函数返回Optional，则使用flatMap。例如:

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);
}

这两个print语句输出的是相同的东西。

对我有帮助的是查看这两个函数的源代码。

映射将结果包装在可选对象中。

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 -返回'raw'对象

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
    }
}

他们做同样的事情。

唯一的区别是，lambda返回的类型被Optional或非Optional包装。

正常使用时，map比flatMap短

例子:

package bj;

import java.util.Optional;

import static java.lang.System.out;

public class App {

    public static void main(String[] args) {
        out.println(Optional.of(10).map    (x ->             x * x));
        out.println(Optional.of(10).flatMap(x -> Optional.of(x * x)));
        out.println(Optional.of(10).map    (x -> Optional.of(x * x).get()));

        out.println(Optional.<Integer>empty().map    (x ->             x * x));
        out.println(Optional.<Integer>empty().flatMap(x -> Optional.of(x * x)));
        out.println(Optional.<Integer>empty().map    (x -> Optional.of(x * x).get()));
    }
}

输出:

Optional[100]
Optional[100]
Optional[100]
Optional.empty
Optional.empty
Optional.empty

你可以参考下面的链接来详细了解(这是我能找到的最好的解释):

https://www.programmergirl.com/java-8-map-flatmap-difference/

map和flatMap - accept函数。map()的返回类型是单个值，而flatMap是返回值流

<R> Stream<R> map(Function<? super T, ? extends R> mapper)

<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

Optional.map ():

获取每个元素，如果值存在，则将其传递给函数:

Optional<T> optionalValue = ...;
Optional<Boolean> added = optionalValue.map(results::add);

现在added有三个值之一:true或false包装成Optional(如果optionalValue存在)，否则为空Optional。

如果你不需要处理结果，你可以简单地使用ifPresent()，它没有返回值:

optionalValue.ifPresent(results::add); 

可选):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()，则结果为空。

好的。你只需要使用'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>。在②，我们想把它映射成一个保险实例，这就是悲剧发生的方式。 根是嵌套的optional。如果我们能得到核心价值，不管外壳如何，我们就能完成它。这就是flatMap所做的。

public Optional<String> getCarInsuranceName(Person person) {
    return person.getOptionalCar()
                 .flatMap(Car::getOptionalInsurance)
                 .map(Insurance::getName);
}

最后，如果你想系统地学习Java8，我强烈推荐《Java8 In Action》。