Optional<T> (Java 8+) é um container que pode ou não conter um valor — uma forma explícita de representar "um valor pode estar ausente" em vez de retornar null. Ajuda a evitar a temida NullPointerException (NPE) forçando os chamadores a considerarem o caso vazio.
User {
userMap.get(id);
}
findUser();
u.getName();
Valores null de retorno são fáceis de ignorar, e a NPE resultante — "o erro de um bilhão de dólares" — é um dos bugs Java mais comuns.
// ✅ the return type ITSELF signals "might be absent" — callers must handle it
public Optional<User> findUser(String id) {
return Optional.ofNullable(userMap.get(id));
}
Agora a assinatura torna a ausência explícita e a API incentivada pelo compilador pressiona os chamadores para lidar com o caso vazio.
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");
Os métodos funcionais (map, filter, orElse, ifPresent) permitem transformar e extrair valores com segurança, encadeando sem verificações null aninhadas.
// ❌ 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 é a ferramenta do Java para lidar com o problema de bugs relacionados a null onipresente, tornando a possibilidade de ausência explícita no sistema de tipos — transformando NPEs silenciosos em um caso tratado.
Seu uso intencional principal é como tipo de retorno para métodos que podem não produzir um valor, onde documenta e força a consideração do caso vazio, e seus métodos funcionais (map, orElse, ifPresent) permitem encadeamento limpo e seguro em relação a null.
Entender como usá-lo corretamente — e os antigos padrões (chamando get() descuidadamente, usando-o para campos/parâmetros, retornando null) — leva a código mais robusto, autodocumentado com menos NPEs, o que é por isso que é tanto uma ferramenta de melhores práticas quanto um tópico comum de entrevista em Java moderno.