Optional<T> (Java 8+) è un contenitore che può o non può contenere un valore — un modo esplicito di rappresentare "un valore potrebbe essere assente" invece di restituire null. Aiuta a prevenire il temuto NullPointerException (NPE) costringendo i chiamanti a considerare il caso vuoto.
User {
userMap.get(id);
}
findUser();
u.getName();
I valori null restituiti sono facili da ignorare, e il conseguente NPE — "l'errore da un miliardo di dollari" — è uno dei bug Java più comuni.
// ✅ the return type ITSELF signals "might be absent" — callers must handle it
public Optional<User> findUser(String id) {
return Optional.ofNullable(userMap.get(id));
}
Ora la firma rende esplicita l'assenza e l'API incoraggiata dal compilatore spinge i chiamanti ad affrontare il caso vuoto.
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");
I metodi funzionali (map, filter, orElse, ifPresent) ti permettono di trasformare e estrarre valori in sicurezza, concatenando senza controlli null annidati.
// ❌ 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 è lo strumento di Java per affrontare il problema pervasivo dei bug legati a null rendendo la possibilità di assenza esplicita nel sistema dei tipi — trasformando gli NPE silenziosi in un caso gestito.
Il suo uso principale previsto è come tipo di ritorno per metodi che potrebbero non produrre un valore, dove documenta e forza la considerazione del caso vuoto, e i suoi metodi funzionali (map, orElse, ifPresent) consentono concatenamento pulito e null-safe.
Capire come usarlo correttamente — e gli anti-pattern (chiamare get() senza cautela, usarlo per campi/parametri, restituire null) — porta a codice più robusto e autodocumentato con meno NPE, motivo per cui è sia uno strumento di best-practice sia un argomento comune nei colloqui Java moderni.