Java Optional: null und NullPointerException vermeiden

Das Problem, das Optional löst

Eine Methode, die womöglich keine Antwort hat, stand in Java schon immer vor einer unangenehmen Wahl: null zurückgeben und hoffen, dass der Aufrufer ans Prüfen denkt. Meist tut er es nicht, und das Ergebnis ist eine NullPointerException, die weit entfernt von der Methode auftaucht, die das null zurückgegeben hat.

Optional<T> ist eine kleine Box, die entweder einen Wert enthält oder explizit leer ist. Indem eine Methode Optional<User> statt User zurückgibt, sagt sie dem Aufrufer schon in ihrer Signatur „das findet möglicherweise nichts" - und der Compiler lenkt ihn dazu, diesen Fall zu behandeln.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> found = Optional.of("Ada");
        Optional<String> missing = Optional.empty();

        System.out.println(found.isPresent());   // true
        System.out.println(missing.isPresent());  // false
    }
}

Ein Optional erstellen

Es gibt drei Factory-Methoden, und die richtige zu wählen ist wichtig:

• Optional.of(value) - der Wert darf nicht null sein, sonst wirft sie auf der Stelle eine NullPointerException.
• Optional.ofNullable(value) - leer, wenn der Wert null ist, sonst gefüllt. Verwende dies, um etwas zu umhüllen, das null sein könnte.
• Optional.empty() - ein leeres Optional.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String maybeNull = System.getenv("DOES_NOT_EXIST");  // gibt null zurück

        Optional<String> safe = Optional.ofNullable(maybeNull);
        System.out.println(safe.isPresent());  // false, keine Ausnahme

        // Optional.of(maybeNull) würde hier NullPointerException werfen
        Optional<String> sure = Optional.of("definitely here");
        System.out.println(sure.isPresent());  // true
    }
}

Ein häufiger Fehler ist, bei einem Wert, der null sein könnte, zu Optional.of(x) zu greifen - das untergräbt den Zweck und wirft genau die Ausnahme, die du vermeiden wolltest. Im Zweifel verwende ofNullable.

Den Wert sicher auslesen

Sobald du ein Optional hast, besteht das Ziel darin, den Wert herauszuholen, ohne anzunehmen, dass er da ist. Das grobe Werkzeug ist get(), und du solltest es fast nie verwenden:

Optional<String> name = Optional.empty();
String value = name.get();   // wirft NoSuchElementException - nur eine getarnte NPE

Liefere stattdessen einen Ersatzwert oder reagiere auf das Vorhandensein. orElse gibt einen Standardwert zurück, wenn es leer ist; ifPresent führt Code nur aus, wenn ein Wert existiert:

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> name = Optional.of("Grace");
        Optional<String> blank = Optional.empty();

        System.out.println(name.orElse("anonymous"));   // Grace
        System.out.println(blank.orElse("anonymous"));  // anonymous

        name.ifPresent(n -> System.out.println("Hello, " + n));
        blank.ifPresent(n -> System.out.println("never prints"));
    }
}

Verwende orElseGet(supplier) statt orElse, wenn der Standardwert teuer zu erzeugen ist - der Supplier läuft nur, wenn das Optional tatsächlich leer ist. Das Argument von orElse wird immer ausgewertet, selbst wenn es nicht gebraucht wird.

orElseThrow für „das sollte existieren"

Manchmal ist leer wirklich ein Fehler - ein erforderlicher Konfigurationswert, ein Nutzer, der in der Datenbank sein sollte. orElseThrow verwandelt ein leeres Optional in eine klare Ausnahme deiner Wahl:

import java.util.Optional;

public class Main {
    static Optional<Integer> parsePort(String raw) {
        try {
            return Optional.of(Integer.parseInt(raw));
        } catch (NumberFormatException e) {
            return Optional.empty();
        }
    }

    public static void main(String[] args) {
        int port = parsePort("8080")
            .orElseThrow(() -> new IllegalStateException("port must be a number"));
        System.out.println("listening on " + port);

        try {
            parsePort("nope")
                .orElseThrow(() -> new IllegalStateException("port must be a number"));
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
        }
    }
}

Das liest sich weitaus besser als ein if (opt.isPresent())-Block und macht den Fehlschlag genau an der Stelle explizit, an der er passiert.

Transformieren mit map und filter

Der eigentliche Gewinn ist das Verketten. map wendet eine Funktion nur dann auf den Wert an, wenn er vorhanden ist, und lässt ein leeres Optional leer - du transformierst also, ohne je einen null anzufassen. filter verwirft den Wert, wenn er einen Test nicht besteht.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> raw = Optional.of("  Coddy  ");

        String result = raw
            .map(String::trim)          // "Coddy"
            .filter(s -> !s.isEmpty())  // nur Nicht-Leeres behalten
            .map(String::toUpperCase)   // "CODDY"
            .orElse("EMPTY");

        System.out.println(result);  // CODDY

        // Ein leeres Optional fließt unberührt durch - keine NPE, keine Verzweigungen
        String none = Optional.<String>empty()
            .map(String::trim)
            .orElse("EMPTY");
        System.out.println(none);    // EMPTY
    }
}

Wenn deine Mapping-Funktion selbst ein Optional zurückgibt, verwende flatMap statt map, um ein umständliches Optional<Optional<T>> zu vermeiden. Das spiegelt die Unterscheidung zwischen map/flatMap wider, die du bei Streams gesehen hast - ein Optional verhält sich sehr ähnlich wie ein Stream aus null oder einem Element.

Wohin Optional gehört (und wohin nicht)

Optional ist als Rückgabetyp für Methoden gedacht, die legitimerweise kein Ergebnis liefern können - die klassischen Beispiele sind Stream.findFirst(), Suchen im Map-Stil und das Parsen. Verwende es dort, und deine API dokumentiert ihre eigenen Lücken.

Es ist nicht gedacht für:

• Felder. Es ist nicht serialisierbar und fügt pro Feld ein Objekt hinzu. Verwende einfache Referenzen und validiere im Konstruktor.
• Methodenparameter. Der Aufrufer muss dann die Argumente in Optional.of(...) verpacken, was lauter ist als eine Überladung oder ein nullbarer Parameter.
• Sammlungen. Gib eine leere List zurück, kein Optional<List>. Eine leere Sammlung bedeutet bereits „nichts".

Als Rückgabetyp behandelt, verwandelt Optional stille null-Bugs in Aufforderungen zur Kompilierzeit, den fehlenden Fall zu behandeln.

Als Nächstes: Ausnahmen

Optional behandelt den alltäglichen Fall „es gibt möglicherweise keinen Wert" sauber, aber manche Fehler sind wirklich außergewöhnlich - eine Datei, die sich nicht öffnen lässt, ein Netzwerk, das abbricht, eine Eingabe, die sich nicht parsen lässt. Java modelliert diese mit Ausnahmen, und das ist die nächste Seite.