Optionals in Java – warum sie so wichtig sind und wie du sie richtig einsetzt

Java • 1. Dezember 2025 • Lesezeit: 6 Minuten

Wenn du mit Java arbeitest, wirst du früher oder später auf das Thema Optional stoßen. Gerade für Einsteiger ist das anfangs oft verwirrend. Warum braucht man das überhaupt? Wieso kann man nicht einfach null verwenden? Und wie geht man richtig damit um? In diesem Beitrag möchte ich dir zeigen, was Optional ist, wofür es gedacht ist und wie du es praktisch einsetzen kannst, um sauberen, lesbaren und sicheren Code zu schreiben.

Bevor wir mit Optional arbeiten, schauen wir uns kurz das Problem an, das es lösen soll.

Das klassische Null-Problem

In älteren Java-Programmen ist null der Standard, wenn eine Methode nichts zurückgeben kann. Das führt aber zu einem bekannten Problem: dem NullPointerException. Fast jeder Java-Entwickler ist schon einmal darüber gestolpert.

// Beispiel ohne Optional
public class PersonService {

    public String findeNachname(String vorname) {
        if ("Max".equals(vorname)) {
            return "Mustermann";
        }
        return null; // Kein Treffer
    }

    public static void main(String[] args) {
        PersonService service = new PersonService();
        String nachname = service.findeNachname("Erika");
        System.out.println(nachname.length()); // Boom!
    }
}

Ausgabe:

Exception in thread "main" java.lang.NullPointerException

Das Programm stürzt ab, weil findeNachname() null zurückgibt, wenn kein Name gefunden wird. Der Aufruf nachname.length() funktioniert also nicht. Genau hier kommt Optional ins Spiel.

Was ist Optional?

Optional ist eine Klasse, die seit Java 8 existiert. Sie kann entweder einen Wert enthalten oder leer sein. Das ist eine elegante Möglichkeit, null zu vermeiden. Statt einfach null zurückzugeben, sagen wir: „Hier ist vielleicht ein Wert – vielleicht aber auch nicht.“

import java.util.Optional;

public class PersonService {

    public Optional<String> findeNachname(String vorname) {
        if ("Max".equals(vorname)) {
            return Optional.of("Mustermann");
        }
        return Optional.empty(); // Kein Wert vorhanden
    }

    public static void main(String[] args) {
        PersonService service = new PersonService();
        Optional<String> nachname = service.findeNachname("Erika");

        if (nachname.isPresent()) {
            System.out.println("Nachname: " + nachname.get());
        } else {
            System.out.println("Keine Person gefunden.");
        }
    }
}

Ausgabe:

Keine Person gefunden.

Hier stürzt nichts mehr ab, selbst wenn kein Nachname gefunden wird. Stattdessen können wir gezielt prüfen, ob ein Wert vorhanden ist.

Optional richtig verwenden

Ein häufiger Fehler von Einsteigern ist, Optional einfach als Ersatz für null zu verwenden – das ist aber nicht die Idee dahinter. Optional soll dir helfen, explizit mit „leeren“ Werten umzugehen, anstatt sie zu verstecken.

Schauen wir uns ein paar saubere Varianten an, wie man mit Optional arbeitet:

import java.util.Optional;

public class Beispiel {

    public static void main(String[] args) {
        Optional<String> optionalName = Optional.of("Marcy");
        System.out.println(optionalName.get()); // Gibt "Marcy" aus

        Optional<String> leer = Optional.empty();

        // Mit ifPresent()
        leer.ifPresent(name -> System.out.println("Name: " + name));
        // Wird nicht ausgefuehrt, weil leer

        // Mit orElse()
        System.out.println(leer.orElse("Unbekannt")); 

        // Mit orElseGet()
        System.out.println(leer.orElseGet(() -> "Default-Wert"));

        // Mit orElseThrow()
        try {
            leer.orElseThrow(() -> new RuntimeException("Kein Wert vorhanden"));
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
        }
    }
}

Ausgabe:

Marcy
Unbekannt
Default-Wert
Kein Wert vorhanden

Du siehst: Mit orElse() oder orElseGet() kannst du direkt einen Ersatzwert angeben. Mit orElseThrow() kannst du gezielt eine Exception werfen, falls kein Wert vorhanden ist.

Optional im praktischen Einsatz

Ein besonders sinnvoller Einsatz ist, wenn du Daten aus einer Datenbank oder API liest, bei denen nicht garantiert ist, dass sie vorhanden sind. Beispiel:

import java.util.Optional;

public class KundenService {

    public Optional<String> findeKundeNachId(int id) {
        if (id == 1) {
            return Optional.of("Hans Meier");
        }
        return Optional.empty();
    }

    public static void main(String[] args) {
        KundenService service = new KundenService();

        String kunde = service.findeKundeNachId(2)
                              .orElse("Kein Kunde gefunden");

        System.out.println(kunde);
    }
}

Ausgabe:

Kein Kunde gefunden

So kannst du ganz einfach Standardwerte zurückgeben, ohne ständig if (x != null) schreiben zu müssen.

Optional in Kombination mit map() und filter()

Eine der elegantesten Seiten von Optional ist, dass du ihn wie einen kleinen Stream verwenden kannst. Du kannst also mit map() oder filter() arbeiten, ohne dich um null zu kümmern.

import java.util.Optional;

public class OptionalMapFilter {

    public static void main(String[] args) {
        Optional<String> name = Optional.of("Erika");

        name.map(String::toUpperCase)
            .filter(n -> n.startsWith("E"))
            .ifPresent(System.out::println);

        Optional<String> leer = Optional.empty();

        leer.map(String::length)
            .ifPresent(System.out::println); // Wird nicht ausgefuehrt
    }
}

Ausgabe:

ERIKA

Hier wird das Optional erst in Großbuchstaben umgewandelt, dann gefiltert, und am Ende ausgegeben – alles ohne eine einzige null-Abfrage. Das ist nicht nur sicherer, sondern auch viel lesbarer.

Wann du Optional besser nicht verwenden solltest

So nützlich Optional ist – es hat auch Grenzen. Du solltest es nicht in Klassenfeldern oder als Parameter von Methoden verwenden. Es ist vor allem für Rückgabewerte gedacht. Wenn du also in einer Methode sagst: „Hier könnte etwas zurückkommen, muss aber nicht“, ist Optional genau richtig.

Ein Beispiel für falsche Verwendung:

public class Kunde {
    private Optional<String> name; // Bitte vermeiden!
}

Besser ist es, intern mit null zu arbeiten (z. B. beim Deserialisieren) und erst beim Zugriff auf die Daten ein Optional zu erzeugen:

public Optional<String> getName() {
    return Optional.ofNullable(name);
}

Fazit

Optional ist kein magischer Ersatz für null, sondern ein Werkzeug, um bewusster mit fehlenden Werten umzugehen. Es zwingt dich als Entwickler, über den Fall „kein Wert vorhanden“ nachzudenken – und das führt automatisch zu robusterem Code.

Wenn du also das nächste Mal eine Methode schreibst, die eventuell nichts zurückgeben kann, überlege dir, ob ein Optional der bessere Weg ist. In den meisten Fällen lautet die Antwort: Ja!

Gerade für Einsteiger ist es ein großartiges Werkzeug, um sicherer und strukturierter zu programmieren – und nebenbei lernst du, warum null in Java so berüchtigt ist.