Optional<T> (Java 8+) ist ein Container, der einen Wert enthalten kann oder auch nicht — eine explizite Methode, um "ein Wert könnte fehlen" darzustellen, statt null zurückzugeben. Es hilft, die gefürchtete NullPointerException (NPE) zu verhindern, indem es Aufrufer dazu zwingt, den leeren Fall zu berücksichtigen.
User {
userMap.get(id);
}
findUser();
u.getName();
Null-Rückgabewerte sind leicht zu übersehen, und die resultierende NPE — "der Milliarden-Dollar-Fehler" — ist einer der häufigsten Java-Bugs.
// ✅ the return type ITSELF signals "might be absent" — callers must handle it
public Optional<User> findUser(String id) {
return Optional.ofNullable(userMap.get(id));
}
Jetzt macht die Signatur die Abwesenheit explizit, und die von Compiler geförderte API drängt Aufrufer, den leeren Fall zu behandeln.
Optional<String> a = Optional.of("hi"); // value present (throws if you pass null)
Optional<String> b = Optional.empty(); // explicitly absent
Optional<String> c = Optional.ofNullable(x); // present if x != null, else empty
Optional<User> user = findUser("123");
// provide a fallback
User u = user.orElse(defaultUser);
User u2 = user.orElseGet(() -> createDefault()); // lazy fallback
User u3 = user.orElseThrow(() -> new NotFoundException());
// run code only if present
user.ifPresent(u -> System.out.println(u.getName()));
// transform without unwrapping (chainable, null-safe)
String name = user.map(User::getName).orElse("Unknown");
String city = user.map(User::getAddress).map(Address::getCity).orElse("N/A");
Die funktionalen Methoden (map, filter, orElse, ifPresent) ermöglichen es dir, Werte sicher zu transformieren und zu extrahieren, Verkettung ohne verschachtelte Null-Prüfungen.
// ❌ defeats the purpose — get() throws if empty, like dereferencing null
if (user.isPresent()) {
User u = user.get(); // verbose AND risky if you forget isPresent()
}
// ✅ use orElse/map/ifPresent instead
// ❌ don't use Optional for fields or method parameters — it's designed for RETURN types
// ❌ never return null from a method that returns Optional
Optional ist Javas Werkzeug zur Bekämpfung des verbreiteten null-bezogenen Bug-Problems, indem es die Möglichkeit der Abwesenheit im Typensystem explizit macht — stille NPEs in einen behandelten Fall umwandelt.
Die wichtigste beabsichtigte Verwendung ist als Rückgabetyp für Methoden, die möglicherweise keinen Wert produzieren, wobei es die Berücksichtigung des leeren Falls dokumentiert und erzwingt, und seine funktionalen Methoden (map, orElse, ifPresent) ermöglichen saubere, null-sichere Verkettung.
Das Verständnis, wie man es korrekt verwendet — und die Anti-Patterns (sorgloses Aufrufen von get(), Verwendung für Felder/Parameter, Rückgabe von null) — führt zu robusterem, selbstdokumentierendem Code mit weniger NPEs, was der Grund ist, warum es sowohl ein Best-Practice-Werkzeug als auch ein häufiges Interviewthema in modernem Java ist.