Optional<T> (Java 8+) est un conteneur qui peut ou non contenir une valeur — une façon explicite de représenter « une valeur pourrait être absente » au lieu de retourner null. Il aide à prévenir la redoutable NullPointerException (NPE) en forçant les appelants à considérer le cas vide.
User {
userMap.get(id);
}
findUser();
u.getName();
Les valeurs null retournées sont faciles à ignorer, et l'NPE qui en résulte — « l'erreur du milliard de dollars » — est l'un des bugs Java les plus courants.
// ✅ the return type ITSELF signals "might be absent" — callers must handle it
public Optional<User> findUser(String id) {
return Optional.ofNullable(userMap.get(id));
}
Maintenant, la signature rend l'absence explicite et l'API encouragée par le compilateur pousse les appelants à gérer le cas vide.
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");
Les méthodes fonctionnelles (map, filter, orElse, ifPresent) vous permettent de transformer et d'extraire des valeurs de façon sûre, en chaînant sans vérifications null imbriquées.
// ❌ 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 est l'outil de Java pour aborder le problème pervasif des bugs liés à null en rendant la possibilité d'absence explicite dans le système de types — transformant les NPEs silencieuses en un cas traité.
Son utilisation principale est comme type de retour pour les méthodes qui pourraient ne pas produire de valeur, où elle documente et impose la considération du cas vide, et ses méthodes fonctionnelles (map, orElse, ifPresent) permettent un chaînage propre et sûr pour null.
Comprendre comment l'utiliser correctement — et les anti-patterns (appeler get() sans soin, l'utiliser pour les champs/paramètres, retourner null) — conduit à un code plus robuste et auto-documenté avec moins d'NPEs, ce qui en fait à la fois un outil de bonne pratique et un sujet d'entrevue courant dans le Java moderne.