Optional<T> (Java 8+) es un contenedor que puede o no contener un valor — una forma explícita de representar "un valor podría estar ausente" en lugar de devolver null. Ayuda a prevenir la temida NullPointerException (NPE) obligando a los llamadores a considerar el caso vacío.
User {
userMap.get(id);
}
findUser();
u.getName();
Los valores nulos de retorno son fáciles de ignorar, y la NPE resultante — "el error de mil millones de dólares" — es uno de los bugs más comunes de 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));
}
Ahora la firma hace que la ausencia sea explícita y la API alentada por el compilador impulsa a los llamadores a tratar el caso vacío.
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");
Los métodos funcionales (map, filter, orElse, ifPresent) te permiten transformar y extraer valores de forma segura, encadenando sin comprobaciones de null anidadas.
// ❌ 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 es la herramienta de Java para abordar el problema generalizado de bugs relacionados con null haciendo que la posibilidad de ausencia sea explícita en el sistema de tipos — convirtiendo NPEs silenciosas en un caso manejado.
Su uso principal previsto es como tipo de retorno para métodos que podrían no producir un valor, donde documenta e impone la consideración del caso vacío, y sus métodos funcionales (map, orElse, ifPresent) permiten encadenamiento limpio y seguro con null.
Comprender cómo usarlo correctamente — y los antipatrones (llamar a get() descuidadamente, usarlo para campos/parámetros, devolver null) — conduce a código más robusto y autodocumentado con menos NPEs, por lo que es tanto una herramienta de mejor práctica como un tema común de entrevista en Java moderno.