Optional<T> (Java 8+) är en behållare som kanske eller kanske inte innehåller ett värde — ett explicit sätt att representera "ett värde kan saknas" istället för att returnera null. Det hjälper till att förhindra det fruktade NullPointerException (NPE) genom att tvinga anropare att överväga det tomma fallet.
User {
userMap.get(id);
}
findUser();
u.getName();
Null-returer är lätta att ignorera, och den resulterande NPE:n — "miljarddollarsmistaken" — är en av de vanligaste Java-buggar.
// ✅ 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 frånvaron explicit och API:et som uppmuntras av kompilatorn tvingar anropare att hantera det tomma fallet.
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 funktionella metoderna (map, filter, orElse, ifPresent) låter dig på ett säkert sätt transformera och extrahera värden, kedja utan kapslade 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 är Java:s verktyg för att tackla det genomgripande problemet med null-relaterade buggar genom att göra möjligheten av frånvaro explicit i typsystemet — omvandla tysta NPE:er till ett hanterat fall.
Den avsedda huvudanvändningen är som en returtyp för metoder som kanske inte producerar ett värde, där den dokumenterar och tvingar övervägande av det tomma fallet, och dess funktionella metoder (map, orElse, ifPresent) möjliggör ren, null-säker kedja.
Att förstå hur man använder den korrekt — och antimönstren (att anropa get() slarvigt, använda den för fält/parametrar, returnera null) — leder till mer robust, självdokumenterad kod med färre NPE:er, vilket är varför det är både ett bästa praxis-verktyg och ett vanligt intervjuämne i modern Java.