Was ist der Unterschied zwischen Optional.flatMap und Optional.map?

Was ist der Unterschied zwischen diesen beiden Methoden: Optional.flatMap() und Optional.map()?

Ein Beispiel wäre wünschenswert.

Benutzen map ob die Funktion das benötigte Objekt zurückgibt oder flatMap wenn die Funktion eine zurückgibt Optional. Zum Beispiel:

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

Beide print-Anweisungen geben dasselbe aus.

Beide übernehmen eine Funktion vom Typ des Optionalen zu etwas.

map() wendet die Funktion “wie es ist” Optional haben Sie:

if (optional.isEmpty()) return Optional.empty();
else return Optional.of(f(optional.get()));

Was passiert, wenn Ihre Funktion eine Funktion von ist T -> Optional<U>?
Ihr Ergebnis ist jetzt ein Optional<Optional<U>>!

Das ist, was flatMap() geht es um: wenn Ihre Funktion bereits eine zurückgibt Optional, flatMap() ist ein bisschen schlauer und wickelt es nicht doppelt ein und kehrt zurück Optional<U>.

Es ist die Zusammensetzung von zwei funktionalen Redewendungen: map und flatten.

Okay. Du Sie müssen ‘flatMap’ nur verwenden, wenn Sie mit verschachtelten Optionals konfrontiert sind. Hier ist das Beispiel.

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

}

Wie Stream gibt Optional#map einen Wert zurück, der von einem Optional umschlossen ist. Deshalb bekommen wir ein verschachteltes Optional — Optional<Optional<Insurance>. Und bei ② wollen wir es als Versicherungsinstanz abbilden, so ist die Tragödie passiert. Die Wurzel sind verschachtelte Optionals. Wenn wir den Kernwert unabhängig von den Hüllen erhalten können, werden wir es schaffen. Das macht flatMap.

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

Am Ende habe ich das dringend empfohlen Java 8 in Aktion an Sie, wenn Sie Java8 systematisch lernen möchten.

Hinweis:- Unten ist die Abbildung der Map- und Flatmap-Funktion, ansonsten ist Optional in erster Linie nur für die Verwendung als Rückgabetyp konzipiert.

Wie Sie vielleicht bereits wissen, ist Optional eine Art Container, der ein einzelnes Objekt enthalten kann oder nicht, sodass es überall dort verwendet werden kann, wo Sie einen Nullwert erwarten (Sie werden NPE möglicherweise nie sehen, wenn Sie Optional richtig verwenden). Wenn Sie beispielsweise eine Methode haben, die ein Personenobjekt erwartet, das nullable sein kann, möchten Sie die Methode vielleicht so schreiben:

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
}

Hier haben Sie einen String-Typ zurückgegeben, der automatisch in einen optionalen Typ eingeschlossen wird.

Wenn die Personenklasse so aussah, ist Telefon auch optional

class Person{
  private Optional<String> phone;
  //setter,getter
}

In diesem Fall umschließt der Aufruf der map-Funktion den zurückgegebenen Wert in Optional und ergibt so etwas wie:

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; Rufen Sie niemals die get-Methode (falls erforderlich) für ein Optional auf, ohne es mit isPresent() zu überprüfen, es sei denn, Sie können nicht ohne NullPointerExceptions leben.

Was mir geholfen hat, war ein Blick in den Quellcode der beiden Funktionen.

Karte – schließt das Ergebnis in ein Optional ein.

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

flachKarte – gibt das ‘rohe’ Objekt zurück

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

• Optional.map():

Nimmt jedes Element und wenn der Wert existiert, wird er an die Funktion übergeben:

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

Jetzt hinzugefügt hat einen von drei Werten: true oder false eingewickelt in ein Optional Wenn optionalValue anwesend war, oder ein leer Optional ansonsten.

Wenn Sie das Ergebnis nicht verarbeiten müssen, können Sie es einfach verwenden ifPresent()es hat keinen Rückgabewert:

optionalValue.ifPresent(results::add); 

• Optional.flatMap():

Funktioniert ähnlich wie die gleiche Methode von Streams. Flacht den Stream von Streams ab. Mit dem Unterschied, dass, wenn der Wert präsentiert wird, er auf Funktion angewendet wird. Andernfalls wird eine leere Option zurückgegeben.

Sie können es verwenden, um Funktionsaufrufe mit optionalen Werten zu erstellen.

Angenommen, wir haben Methoden:

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

Dann können Sie die Quadratwurzel der Inversen berechnen, wie:

Optional<Double> result = inverse(-4.0).flatMap(MyMath::squareRoot);

oder, wenn Sie es vorziehen:

Optional<Double> result = Optional.of(-4.0).flatMap(MyMath::inverse).flatMap(MyMath::squareRoot);

Wenn entweder die inverse() oder der squareRoot() kehrt zurück Optional.empty()das Ergebnis ist leer.

Sie können sich auf den folgenden Link beziehen, um es im Detail zu verstehen (beste Erklärung, die ich finden konnte):

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

Sowohl map als auch flatMap – Accept Function. Der Rückgabetyp von map() ist ein einzelner Wert, während flatMap einen Strom von Werten zurückgibt

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

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