Java Academy · Lektion

Optionals transformieren: map und flatMap

Verketten Sie Transformationen mit map und flatMap, um Werte ohne Null-Prüfungen zu verarbeiten.

Optionals transformieren: map und flatMap ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Optionals transformieren: map und flatMap

map() transformiert den Wert innerhalb eines Optional, wenn er vorhanden ist. flatMap() verhindert verschachtelte Optionals, wenn die Transformation selbst ein Optional zurückgibt.

map: Den Wert transformieren

map(Function) wendet die Funktion auf den Wert an, wenn er vorhanden ist, und verpackt das Ergebnis in ein neues Optional. Wenn das ursprüngliche Optional leer ist, wird ebenfalls ein leeres Optional zurückgegeben.

import java.util.Optional;

Optional<String> name = Optional.of("alice");

Optional<String> upper = name.map(String::toUpperCase);
System.out.println(upper.get()); // ALICE

Optional<Integer> length = name.map(String::length);
System.out.println(length.get()); // 5

// Empty in → empty out
Optional<String> empty = Optional.<String>empty().map(String::toUpperCase);
System.out.println(empty.isPresent()); // false

map-Aufrufe verketten

Mehrere map-Aufrufe verketten Transformationen übersichtlich, ohne verschachtelte Null-Prüfungen.

import java.util.Optional;

record Address(String city, String country) {}
record User(String name, Address address) {}

User user = new User("Alice", new Address("New York", "US"));

// Chain of maps — safe even if any step returns null
Optional<String> city = Optional.ofNullable(user)
    .map(User::address)
    .map(Address::city)
    .map(String::toUpperCase);

System.out.println(city.orElse("Unknown")); // NEW YORK

flatMap: Optional<Optional> vermeiden

Wenn Ihre Mapping-Funktion Optional zurückgibt, verwenden Sie flatMap, damit ein flaches Optional statt eines verschachtelten Optional<Optional> entsteht.

import java.util.Optional;

record User(String name, Optional<String> email) {}

User u = new User("Bob", Optional.of("bob@example.com"));

// map returns Optional<Optional<String>> — ugly!
Optional<Optional<String>> nested = Optional.of(u).map(User::email);

// flatMap flattens: Optional<String>
Optional<String> flat = Optional.of(u).flatMap(User::email);
System.out.println(flat.get()); // bob@example.com

flatMap in der Praxis: Repository-Kette

Ein häufiges Muster: Repository-Suchen verketten, bei denen jede Suche ein Optional zurückgibt.

import java.util.Optional;

record Order(long id, long userId, double total) {}
record User(long id, String name, String email) {}

static Optional<Order> findOrder(long orderId) {
    return orderId == 1 ? Optional.of(new Order(1, 42, 99.99)) : Optional.empty();
}
static Optional<User> findUser(long userId) {
    return userId == 42 ? Optional.of(new User(42, "Alice", "a@co.com")) : Optional.empty();
}

Optional<String> email = findOrder(1)
    .flatMap(o -> findUser(o.userId()))
    .map(User::email);

System.out.println(email.orElse("Not found")); // a@co.com

Zusammenfassung zu map und flatMap

So wählen Sie zwischen map und flatMap:

Verwenden Sie map, wenn die Funktion einen einfachen Wert zurückgibt (String, Integer)
Verwenden Sie flatMap, wenn die Funktion ein Optional zurückgibt

import java.util.Optional;

// map: T → R
Optional.of("hello").map(String::toUpperCase);       // Optional<String>
Optional.of("42").map(Integer::parseInt);             // Optional<Integer>

// flatMap: T → Optional<R>
Optional.of("42").flatMap(s -> {
    try { return Optional.of(Integer.parseInt(s)); }
    catch (NumberFormatException e) { return Optional.empty(); }
}); // Optional<Integer> (not Optional<Optional<Integer>>)

Sicheres Parsen mit flatMap

Ein elegantes Muster: Riskante Vorgänge, die fehlschlagen können, mit flatMap in ein Optional verpacken.

import java.util.Optional;

static Optional<Integer> tryParseInt(String s) {
    try { return Optional.of(Integer.parseInt(s)); }
    catch (NumberFormatException e) { return Optional.empty(); }
}

Optional<String> input = Optional.of("123");
Optional<Integer> parsed = input.flatMap(JavaOptional::tryParseInt);
System.out.println(parsed.map(n -> n * 2).orElse(-1)); // 246

Optional<String> bad = Optional.of("abc");
Optional<Integer> failed = bad.flatMap(JavaOptional::tryParseInt);
System.out.println(failed.orElse(-1)); // -1

Optionals sammeln

Filtern und mappen Sie einen Stream von Optionals, um nur die vorhandenen Werte zu sammeln.

import java.util.*;
import java.util.stream.*;

List<String> inputs = List.of("10", "abc", "25", "nope", "7");

List<Integer> numbers = inputs.stream()
    .flatMap(s -> {
        try { return Stream.of(Integer.parseInt(s)); }
        catch (NumberFormatException e) { return Stream.empty(); }
    })
    .collect(Collectors.toList());

System.out.println(numbers); // [10, 25, 7]

Verschachtelte Objekte durchlaufen

Mit map und flatMap können Sie tiefe Objektgraphen sicher durchlaufen, ohne umständliche Null-Prüfungen.

import java.util.Optional;

record Company(String name, Optional<Address> address) {}
record Address(String city, Optional<String> zipCode) {}

Company company = new Company(
    "Acme Corp",
    Optional.of(new Address("Austin", Optional.of("78701")))
);

String zip = Optional.of(company)
    .flatMap(Company::address)
    .flatMap(Address::zipCode)
    .orElse("N/A");

System.out.println(zip); // 78701

map für Typkonvertierungen

map eignet sich hervorragend zum Konvertieren des Typs von Optional-Werten – beispielsweise zum Parsen, Formatieren oder Extrahieren eines Unterfelds.

import java.util.Optional;
import java.time.LocalDate;

// Parse a date from String safely
static Optional<LocalDate> parseDate(String s) {
    try { return Optional.of(LocalDate.parse(s)); }
    catch (Exception e) { return Optional.empty(); }
}

Optional<String> dateStr = Optional.of("2024-06-15");
Optional<Integer> year = dateStr
    .flatMap(JavaOptional::parseDate)
    .map(LocalDate::getYear);

System.out.println(year.orElse(-1)); // 2024

Pipelines erstellen

Durch die Kombination von filter, map und flatMap entstehen ausdrucksstarke Datenpipelines, die das Fehlen eines Werts in jedem Schritt ohne explizite Null-Prüfungen behandeln.

import java.util.Optional;

record Product(String sku, String category, boolean inStock, double price) {}

static Optional<Product> findProduct(String sku) {
    if ("LAPTOP-1".equals(sku))
        return Optional.of(new Product("LAPTOP-1", "Electronics", true, 999.99));
    return Optional.empty();
}

Optional<String> priceTag = findProduct("LAPTOP-1")
    .filter(Product::inStock)
    .filter(p -> p.price() < 2000)
    .map(p -> String.format("%s: $%.2f", p.sku(), p.price()));

System.out.println(priceTag.orElse("Not available")); // LAPTOP-1: $999.99

Kurze Wissensprüfung

Wann sollten Sie bei einem Optional flatMap statt map verwenden?

Zusammenfassung: Optionals transformieren: map und flatMap

Die wichtigsten Erkenntnisse:

map() transformiert den Wert, wenn er vorhanden ist, und verpackt das Ergebnis in ein Optional
flatMap() ist für Funktionen gedacht, die ein Optional zurückgeben, und verhindert verschachtelte Optionals
Verketten Sie mehrere map-Aufrufe für mehrstufige Transformationen ohne Null-Prüfungen
Verwenden Sie flatMap, um Repository- oder Service-Aufrufe zu verketten, die ein Optional zurückgeben
Kombinieren Sie filter + map + flatMap zu null-sicheren Datenpipelines
Verwenden Sie flatMap Optional::stream, um Optionals in Stream-Pipelines einzubinden

Häufig gestellte Fragen

Ist die Lektion „Optionals transformieren: map und flatMap“ kostenlos?

Ja — der vollständige Text von „Optionals transformieren: map und flatMap“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Optionals transformieren: map und flatMap“?

Verketten Sie Transformationen mit map und flatMap, um Werte ohne Null-Prüfungen zu verarbeiten. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Optionals transformieren: map und flatMap“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Warum Optional existiert
Optionals erstellen und untersuchen
Optionals transformieren: map und flatMap
Best Practices für Optional

← Zurück zu Java Academy