Optional<T> (Java 8+) er en container, der kan eller ikke kan indeholde en værdi — en eksplicit måde at repræsentere "en værdi kan være fraværende" i stedet for at returnere null. Det hjælper med at forhindre den frygtet NullPointerException (NPE) ved at tvinge opkaldere til at overveje det tomme tilfælde.
User {
userMap.get(id);
}
findUser();
u.getName();
Null-returværdier er nemme at ignorere, og den resulterende NPE — "fejlen på en milliard dollar" — er en af de mest almindelige Java-fejl.
// ✅ the return type ITSELF signals "might be absent" — callers must handle it
public Optional<User> findUser(String id) {
return Optional.ofNullable(userMap.get(id));
}
Nu gør signaturen fravær eksplicit, og compiler-opmuntret API'en ansporrer opkaldere til at håndtere det tomme tilfælde.
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");
De funktionelle metoder (map, filter, orElse, ifPresent) giver dig mulighed for sikkert at transformere og udtrække værdier, kæde uden indlejrede null-kontroller.
// ❌ 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 er Java's værktøj til at tackle det udbredt null-relateret fejl-problem ved at gøre muligheden for fravær eksplicit i typesystemet — og omdannes stille NPE'er til et håndteret tilfælde.
Dets vigtigste tilsigtede brug er som en returtype for metoder, der muligvis ikke producerer en værdi, hvor det dokumenterer og håndhæver overvejelse af det tomme tilfælde, og dets funktionelle metoder (map, orElse, ifPresent) muliggør ren, null-sikker kæding.
At forstå, hvordan man bruger det korrekt — og anti-mønstre (sorgeløst at kalde get(), bruge det til felter/parametre, returnere null) — fører til mere robust, selvdokumenterende kode med færre NPE'er, hvilket er grunden til, at det både er et best-practice-værktøj og et almindeligt interviewemne i moderne Java.