Java Optional-Klasse | W3Docs Learn Java

Optional<T> ist ein Container, der entweder einen Wert vom Typ T oder nichts enthält — und Ihnen auf Typebene mitteilt, welches der Fall ist, sodass der Compiler Sie zwingen kann, den fehlenden Fall zu behandeln. Es wurde in Java 8 zusammen mit Streams hinzugefügt, und beide sind so konzipiert, dass sie zusammenpassen: findFirst, findAny, min, max, reduce geben alle Optional<T> zurück, genau weil die Antwort möglicherweise nicht existiert, und die API bietet Ihnen fließende Möglichkeiten, weiterzurechnen, ohne jemals if (x != null) zu schreiben.

Optional ist kein universeller Ersatz für null, und das JDK hat klare Vorstellungen davon, wo es hingehört. Dieses Kapitel führt durch die gesamte API und zeigt dann die drei Stellen, an denen Optional die falsche Wahl ist.

Erstellen eines `Optional`

Drei Konstruktoren, jeder mit einer präzisen Bedeutung:

Optional<String> a = Optional.of("hello");           // present; null arg throws NPE
Optional<String> b = Optional.empty();                // absent
Optional<String> c = Optional.ofNullable(maybeNull);  // present if non-null, else empty

Der Unterschied ist wichtig. Optional.of(x) ist die Aussage „Dieser Wert ist definitiv vorhanden" — wenn Sie null übergeben, wird sofort NullPointerException geworfen, was das Gewünschte ist (ein Fehler an der Quelle, nicht drei Frames weiter unten). Optional.ofNullable(x) ist der Adapter, den Sie um eine Legacy-API wickeln, die null für „nicht vorhanden" zurückgibt.

In einer Stream-Pipeline erstellen Sie ein Optional fast nie von Hand — Terminale wie findFirst und Collectors.maxBy erzeugen sie für Sie.

Abfragen, ob ein Wert vorhanden ist

Die zwei Abfragen:

Optional<String> opt = lookup(id);
boolean has = opt.isPresent();      // true if a value is held
boolean none = opt.isEmpty();        // Java 11+ -- the opposite of isPresent

Diese erscheinen in Produktionscode, sind aber meist ein Code Smell: Der meiste Code, der isPresent und dann get aufruft, wäre mit einer der unten beschriebenen operate-on-it-Methoden lesbarer. Die Abfragemethoden sind für Grenzcode gedacht, bei dem Sie wirklich einen boolean benötigen — eine Guard-Klausel, eine Routing-Entscheidung, ein Logging-Zweig.

Den Wert sicher lesen

Der falsche Weg:

String name = opt.get();   // throws NoSuchElementException if empty

opt.get() ist das unkontrollierte Lesen. Damit wandeln Sie ein Optional zurück in einen Wert und eine Laufzeitausnahme um — genau das, was der Typ verhindern sollte. Verwenden Sie es nur, nachdem Sie bewiesen haben, dass das Optional vorhanden ist (oder nach findFirst().orElseThrow() aus einer Pipeline, bei der ein leeres Ergebnis ein Programmiererfehler wäre, kein erwarteter Fall).

Die richtigen Wege, in Reihenfolge der Präferenz:

String name1 = opt.orElse("anonymous");                          // default value
String name2 = opt.orElseGet(() -> expensiveDefault());          // lazy default
String name3 = opt.orElseThrow();                                 // NoSuchElementException
String name4 = opt.orElseThrow(() -> new MyDomainError(id));      // custom exception

orElse(value) — liefert einen Standardwert. Der Wert wird immer ausgewertet, auch wenn das Optional vorhanden ist. Übergeben Sie daher keinen teuren Ausdruck.
orElseGet(supplier) — liefert einen Standardwert lazy. Der Supplier läuft nur, wenn das Optional leer ist. Verwenden Sie dies für jeden Standard, der mehr kostet als ein Literal.
orElseThrow() — wirft NoSuchElementException wenn abwesend. Die parameterlose Form ab Java 10 ist das moderne Äquivalent von opt.get(), wenn „dies muss definitiv vorhanden sein" die einzig sinnvolle Interpretation an der Aufrufstelle ist.
orElseThrow(supplier) — wirft eine domänenspezifische Ausnahme. Der Standardweg, um „abwesend" in „404 not found" zu übersetzen.

Den Wert transformieren — `map`

Wenn das Optional vorhanden ist, eine Funktion anwenden; andernfalls leer bleiben:

Optional<String> upper = opt.map(String::toUpperCase);
Optional<Integer> len   = opt.map(String::length);

Die Signatur lautet Optional<T>.map(Function<T, R>) -> Optional<R>. Die Funktion wird nur ausgeführt, wenn ein Wert vorhanden ist — kein null-Check, kein if, kein else. Dies ist die Operation, die Optional seinen Zeichenaufwand wert macht: Die meisten Ketten von „wenn nicht-null, tue dies; wenn nicht-null, tue dann dies" kollabieren zu .map(...).map(...).map(...).

Es gibt einen Sonderfall, den das JDK stillschweigend behandelt: Wenn Ihre map-Funktion null zurückgibt (weil sie eine Legacy-API umhüllt, die null für „kein Ergebnis" zurückgibt), ist das resultierende Optional empty() — nicht Optional.of(null).

Optionals zusammensetzen — `flatMap`

Wenn die Mapping-Funktion selbst ein Optional zurückgibt, würde map ein Optional<Optional<T>> erzeugen. flatMap flacht es ab:

record User(String id, Optional<Address> address) {}
record Address(String city) {}

Optional<String> city = userById(id)
    .flatMap(User::address)        // Optional<Address>
    .map(Address::city);            // Optional<String>

flatMap ist die Operation, die es Ihnen ermöglicht, mehrere Lookups — von denen jeder fehlschlagen kann — in einer einzigen Pipeline zu verketten. Beide Fehlerfälle kollabieren am Ende zu Optional.empty(), und der Consumer behandelt sie einmal mit orElse / orElseThrow.

Filtern — `filter`

Prüft den Wert gegen ein Predicate<T>; gibt dasselbe Optional zurück, wenn es besteht, empty() wenn nicht:

Optional<String> nonBlank = opt.filter(s -> !s.isBlank());
Optional<Integer> positive = numberOpt.filter(n -> n > 0);

Wirkt als Guard innerhalb der Optional-Pipeline. Nützlich, wenn die Frage lautet: „Ich habe einen Wert, aber ist er der richtige Wert, um fortzufahren?"

Seiteneffekte — `ifPresent`, `ifPresentOrElse`

Code nur ausführen, wenn der Wert vorhanden ist:

opt.ifPresent(name -> log.info("hello, {}", name));

Oder einen Zweig ausführen, wenn vorhanden, und einen anderen, wenn leer (Java 9+):

opt.ifPresentOrElse(
    name -> log.info("hello, {}", name),
    () -> log.warn("no name on the request"));

Dies ist der richtige Weg, um „tue etwas nebenbei" auszudrücken. Sie ersetzen das Muster if (opt.isPresent()) { use(opt.get()); } vollständig.

Brücke zu Streams — `Optional.stream()`

(Java 9+) Wandelt ein Optional<T> in einen Stream<T> mit null oder einem Element um:

Stream<String> s = opt.stream();

Nützlich innerhalb von flatMap auf einem Stream<Optional<T>>:

List<String> presentCities = userIds.stream()
    .map(this::userById)           // Stream<Optional<User>>
    .flatMap(Optional::stream)      // Stream<User>     -- empties drop, presents pass through
    .map(User::city)
    .toList();

Das ersetzt filter(Optional::isPresent).map(Optional::get) durch ein einzelnes flatMap(Optional::stream). Gleiches Ergebnis, sauberere Pipeline.

`or` — Rückfall auf ein anderes `Optional`

(Java 9+) Wenn leer, einen Supplier eines anderen Optional verwenden:

Optional<User> u = primaryLookup(id)
    .or(() -> fallbackLookup(id))
    .or(() -> Optional.of(User.anonymous()));

Liest sich als „versuche primär; wenn abwesend, versuche Fallback; wenn abwesend, verwende anonym." Alle drei sind Optional<User>; die Kette gibt das erste nicht-leere zurück. Unterschied zu orElse — or hält das Ergebnis eingewickelt; orElse wickelt es mit einem einfachen T-Standard aus.

Primitive Spezialisierungen

Es gibt OptionalInt, OptionalLong, OptionalDouble für primitive Ergebnisse — was z. B. IntStream.max() zurückgibt:

OptionalInt max = nums.stream().mapToInt(Integer::intValue).max();
int hi = max.orElse(0);

Sie haben eine kleinere API — kein map/flatMap/filter — weil sie an der Grenze der primitiven Welt sitzen. Verwenden Sie sie, um primitive-Stream-Ergebnisse zu lesen; konvertieren Sie zu Optional<Integer>, wenn Sie die vollständige API benötigen.

Wo `Optional` nicht hingehört

Die Designabsicht des JDK ist eng gefasst: Optional ist ein Rückgabetyp für Methoden, deren Antwort möglicherweise nicht existiert. Es ist kein:

Feldtyp. Schreiben Sie nicht private Optional<String> middleName;. Es ist nicht Serializable, kostet pro Feld eine Allokation, und ein null-Feld ist kürzer und klarer für „Diese Entität hat keinen zweiten Vornamen." Die richtige Vorgehensweise ist ein nicht-Optional-Feld, das null sein kann, mit einem Getter, der Optional zurückgibt.
Methodenparameter. Akzeptieren Sie kein Optional<String> als Argument. Überladen Sie die Methode, oder akzeptieren Sie String und dokumentieren Sie, dass null „abwesend" bedeutet. Optionale Parameter zwingen den Aufrufer zum Einwickeln, was Rauschen erzeugt.
Collection-Element. List<Optional<T>> ist fast immer eine Liste mit nullable Elementen und zusätzlichem Einwickeln. Verwenden Sie List<T> und filtern Sie die Nulls an der Grenze heraus, oder verwenden Sie flatMap(Optional::stream), um die Abwesenden in einer Pipeline zu verwerfen.
Ein Weg, alle null zu vermeiden. Java hat immer noch null in jedem Referenztyp; Optional ist für die Rückgabeform von Code, der Werte produziert, die möglicherweise nicht existieren. Einfache Referenztypen sind für alles andere in Ordnung.

Die kürzere Regel: Ein Optional, das aus einer Methode fließt, ist gutes Design; ein Optional, das hinein fließt, ist fast immer falsch.

Ein ausgearbeitetes Beispiel: jede Methode und die Faustregeln im Code

Das folgende Programm erstellt einen kleinen Benutzer/Adress-Graphen, durchläuft jede Methode von Optional dagegen, demonstriert das Auswertungstiming von orElse vs. orElseGet, die Optional.stream()-Brücke und die or-Kette.

java— editable, runs on the server

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

public class OptionalShowcase {
  record Address(String city) {}
  record User(String id, String name, Optional<Address> address) {}

// Repository: returns Optional<User>, never null.
  static Optional<User> userById(String id) {
    return switch (id) {
      case "u1" -> Optional.of(new User("u1", "Alice", Optional.of(new Address("Yerevan"))));
      case "u2" -> Optional.of(new User("u2", "Bob",    Optional.empty()));
      case "u3" -> Optional.of(new User("u3", "",       Optional.of(new Address("Paris"))));
      default   -> Optional.empty();
    };
  }

public static void main(String[] args) {
    // ---- constructors ----
    Optional<String> ofX     = Optional.of("hello");
    Optional<String> empty   = Optional.empty();
    Optional<String> nullable = Optional.ofNullable(null);   // -> empty
    System.out.println("of(hello)        = " + ofX);
    System.out.println("empty            = " + empty);
    System.out.println("ofNullable(null) = " + nullable);

try { Optional.of((String) null); }
    catch (NullPointerException e) { System.out.println("Optional.of(null) -> NPE (as designed)"); }

// ---- isPresent / isEmpty ----
    System.out.println("\nofX.isPresent  = " + ofX.isPresent()
        + " | empty.isEmpty = " + empty.isEmpty());

// ---- orElse vs. orElseGet (evaluation timing) ----
    int[] computeCount = {0};
    java.util.function.Supplier<String> expensive = () -> {
      computeCount[0]++;
      return "computed-" + computeCount[0];
    };
    String present1 = ofX.orElse(expensive.get());        // ALWAYS evaluates the arg
    String present2 = ofX.orElseGet(expensive);            // SKIPS the supplier when present
    String absent1  = empty.orElse(expensive.get());      // evaluates the arg AND uses it
    String absent2  = empty.orElseGet(expensive);          // evaluates and uses
    System.out.println("\norElse / orElseGet evaluation count after 4 calls: " + computeCount[0]
        + "  (orElse: always; orElseGet: only when empty)");
    System.out.println("present1=" + present1 + "  present2=" + present2
        + "  absent1=" + absent1 + "  absent2=" + absent2);

// ---- map and flatMap ----
    Optional<Integer> len = ofX.map(String::length);
    Optional<String>  city = userById("u1").flatMap(User::address).map(Address::city);
    Optional<String>  noCity = userById("u2").flatMap(User::address).map(Address::city);   // missing
    System.out.println("\nofX.map(length)            = " + len);
    System.out.println("u1 -> city                  = " + city);
    System.out.println("u2 -> city (no address)    = " + noCity);

// ---- filter ----
    Optional<String> nonBlankName = userById("u3").map(User::name).filter(n -> !n.isBlank());
    System.out.println("u3 name filtered non-blank = " + nonBlankName);

// ---- ifPresent / ifPresentOrElse ----
    userById("u1").ifPresent(u -> System.out.println("\nifPresent      -> hello, " + u.name()));
    userById("none").ifPresentOrElse(
        u -> System.out.println("hello " + u.name()),
        () -> System.out.println("ifPresentOrElse -> no such user"));

// ---- or (alternative Optional) ----
    Optional<User> u = userById("none")
        .or(() -> userById("u2"))
        .or(() -> Optional.of(new User("anon", "anonymous", Optional.empty())));
    System.out.println("\nor-chain result = " + u.orElseThrow().name());

// ---- Optional.stream() bridge ----
    List<String> ids = List.of("u1", "none", "u2", "u3", "u4");
    List<String> names = ids.stream()
        .map(OptionalShowcase::userById)   // Stream<Optional<User>>
        .flatMap(Optional::stream)          // Stream<User>
        .map(User::name)
        .toList();
    System.out.println("\nflatMap(Optional::stream) names = " + names);

// ---- orElseThrow with a domain exception ----
    try {
      User must = userById("none").orElseThrow(() -> new NoSuchElementException("user 'none' missing"));
      System.out.println(must);
    } catch (NoSuchElementException e) {
      System.out.println("\norElseThrow custom -> " + e.getMessage());
    }

// ---- Primitive Optionals ----
    OptionalInt firstSquareOver50 = IntStream.rangeClosed(1, 100)
        .map(n -> n * n)
        .filter(n -> n > 50)
        .findFirst();
    System.out.println("\nfirst square > 50 = " + firstSquareOver50.orElse(-1));
  }
}

Was aus dem Durchlauf zu entnehmen ist:

Die drei Konstruktoren of, empty, ofNullable bilden drei klare Absichten ab: definitiv vorhanden, definitiv abwesend und Legacy-Adapter, vorhanden-wenn-nicht-null. Optional.of(null) wirft — und das ist der gewünschte Fehler, kein Bug, den man umgehen sollte.
orElse wertete sein Argument jedes Mal aus, auch wenn das Optional vorhanden war. Der Supplier von orElseGet lief nur bei Bedarf. Verwenden Sie orElse für günstige Literale und orElseGet für alles, was alloziert, abfragt oder wirft.
map und flatMap ließen die gesamte Kette userById(...).flatMap(User::address).map(Address::city) als einzelne Pipeline lesen — keine null-Checks, keine verschachtelten Ifs, und jeder leere Schritt kurzschließt am Ende zu Optional.empty().
flatMap(Optional::stream) verwandelte einen Stream<Optional<User>> in einen Stream<User>, wobei alle Abwesenden in einem Schritt verworfen wurden. Das ist der saubere Weg, eine Liste von „kann-scheitern"-Lookups in einen Stream von Erfolgen zu überbrücken.
OptionalInt ist das, was primitive-Stream-Terminale wie IntStream.findFirst zurückgeben. Es hat seine eigene kleine API (getAsInt, orElse, ifPresent) und existiert, damit primitive Pipelines nie boxen müssen.
Die Faustregel für „falsche Orte" tauchte implizit auf: User.address war ein Optional<Address>-Feld — für das Beispiel in Ordnung, da es die API demonstrieren wollte, aber im Produktionscode wäre das Feld ein möglicherweise-null-Address mit einem Optional<Address> address()-Getter, der das Einwickeln übernimmt.

Wie es weitergeht

Teil 12 behandelte das funktionale Vokabular von Anfang bis Ende: funktionale Interfaces, Lambdas, Methodenreferenzen, die eingebauten Typen, die Stream-Pipeline, jede Quelle, jedes Intermediate, jedes Terminal, Collectors, parallele Ausführung und schließlich Optional als Ausdruck von Abwesenheit auf Typebene. Das nächste Kapitel, Java Predicate Interface, zoomt auf ein einzelnes funktionales Interface zurück — Predicate<T> — und die Kombinator-Algebra (and, or, negate, isEqual, not), die es Ihnen ermöglicht, Prädikate zusammenzusetzen, ohne jemals den booleschen Klebstoff von Hand zu schreiben. Von dort aus setzt sich der Teil mit Function, Consumer/Supplier und der binären Operator-Familie fort — ein Interface pro Kapitel, jedes mit der gleichen Beispielstruktur, die Sie hier gesehen haben.

Übungen

Übung

Sie haben `Optional<String> opt` und benötigen einen Standardwert, wenn er leer ist, wobei der Standard ein teurer Aufruf von `loadDefaultFromDb()` ist. Was ist korrekt *und* vermeidet den teuren Aufruf, wenn `opt` vorhanden ist?

`opt.orElseGet(() -> loadDefaultFromDb())` — `orElseGet` nimmt einen `Supplier`, der nur aufgerufen wird, wenn das Optional leer ist`opt.orElse(loadDefaultFromDb())` — `orElse` kurzschließt und wertet sein Argument nur bei Bedarf aus`opt.isPresent() ? opt.get() : loadDefaultFromDb()` — dies ist das idiomatische Optional-Muster`opt.or(loadDefaultFromDb())` — `or` akzeptiert einen Standardwert vom Typ `T`

Erstellen eines Optional

Abfragen, ob ein Wert vorhanden ist

Den Wert sicher lesen

Den Wert transformieren — map

Optionals zusammensetzen — flatMap

Filtern — filter

Seiteneffekte — ifPresent, ifPresentOrElse

Brücke zu Streams — Optional.stream()

or — Rückfall auf ein anderes Optional