Optional<T> (Java 8+) este un container care poate sau nu să conțină o valoare — o modalitate explicită de a reprezenta "o valoare poate fi absentă" în loc de a returna null. Ajută la prevenirea temutei NullPointerException (NPE) forțând apelantii să ia în considerare cazul gol.
User {
userMap.get(id);
}
findUser();
u.getName();
Valorile null de return sunt ușor de ignorat, iar NPE-ul rezultat — "greșeala de un miliard de dolari" — este una dintre cele mai frecvente bug-uri Java.
// ✅ the return type ITSELF signals "might be absent" — callers must handle it
public Optional<User> findUser(String id) {
return Optional.ofNullable(userMap.get(id));
}
Acum semnătura face absența explicită și API-ul încurajat de compilator forțează apelantii să se ocupe de cazul gol.
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");
Metodele funcționale (map, filter, orElse, ifPresent) vă permit să transformați și extrageți valori în siguranță, lucru în lanț fără verificări null imbricate.
// ❌ 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 este instrumentul Java pentru a se ocupa de problema omniprezentă a bug-urilor legate de null prin a face absența explicită în sistemul de tipuri — transformând NPE-urile silențioase într-un caz tratat.
Utilizarea sa principală intenționată este ca tip de returnare pentru metode care este posibil să nu producă o valoare, unde documentează și impune considerarea cazului gol, iar metodele sale funcționale (map, orElse, ifPresent) permit lucrul în lanț curat și sigur din punct de vedere al null.
Înțelegerea modului de utilizare corectă — și a antipattern-urilor (apelul neglijent get(), utilizarea sa pentru câmpuri/parametri, returnarea null) — duce la cod mai robust, autodocumentat cu mai puține NPE-uri, ceea ce este motivul pentru care este atât un instrument de bune practici, cât și un subiect frecvent de interviu în Java modern.