O Tipo Optional em Java

Introduzido no Java 8, o Optional<T> não é apenas uma classe utilitária para evitar NullPointerException; trata-se de uma mudança de paradigma. Ele foi projetado para nos forçar a lidar explicitamente com a possibilidade de um valor ausente, substituindo a verificação imperativa (if (valor != null)) por uma abordagem funcional e declarativa.

Criando um Optional: A Maneira Correta

Antes de consumir um Optional, você precisa criá-lo. A escolha do método de fábrica é a primeira decisão importante.

• Optional.of(valor): Use quando você tem certeza de que o valor não é nulo. Lançará um NullPointerException se você passar null, agindo como uma verificação de contrato.
• Optional.ofNullable(valor): Use quando um valor pode ser nulo. Este é o método mais seguro e comum para encapsular valores de fontes externas (como bancos de dados ou chamadas de API). Ele retorna um Optional vazio se o valor for null.
• Optional.empty(): Use para criar explicitamente um Optional vazio, indicando claramente a ausência de um resultado.

O Anti-Padrão: Por Que Evitar isPresent() e get()

A primeira tentação de quem aprende Optional é replicar a antiga lógica nula:

// Não faça isso: Este é um anti-padrão.
Optional<String> optionalName = ...;
if (optionalName.isPresent()) {
    String name = optionalName.get();
    // faz algo com o nome...
}

Este código é verboso e perde todos os benefícios da abordagem funcional do Optional. Se você se pegar escrevendo isPresent(), pare e considere uma das alternativas a seguir. O método get() só deve ser usado em raras situações onde a lógica do código já garante a presença do valor.

A Maneira Correta: Declarando Intenções

A verdadeira força do Optional está em seus métodos que declaram o que fazer em cada cenário, em vez de como verificar.

1. Executando uma Ação: ifPresent e ifPresentOrElse

Quando usar: Se você só precisa executar um código (um efeito colateral, como imprimir ou salvar) e não precisa de um valor de retorno.

• ifPresent(consumer): Executa uma ação apenas se o valor estiver presente.
• ifPresentOrElse(consumer, runnable): Executa a primeira ação se o valor estiver presente, ou a segunda se estiver ausente.

Optional<String> presentName = Optional.of("Ana");
presentName.ifPresent(name -> System.out.println("Bem-vindo, " + name));

Optional<String> absentName = Optional.empty();
absentName.ifPresentOrElse(
    name -> System.out.println("Bem-vindo, " + name),
    () -> System.out.println("Usuário não encontrado. Por favor, registre-se.")
);

2. Recuperando um Valor com Segurança: orElse, orElseGet e orElseThrow

Quando usar: Se você precisa "desembrulhar" o Optional e obter um valor concreto, com um plano B para o caso de ele estar vazio.

• orElse(defaultValue): Retorna o valor se presente; caso contrário, retorna defaultValue. Atenção: defaultValue é sempre avaliado.
• orElseGet(supplier): Retorna o valor se presente; caso contrário, invoca o supplier para gerar um valor padrão. Use este método se a criação do valor padrão for custosa.
• orElseThrow(exceptionSupplier): Retorna o valor se presente; caso contrário, lança a exceção fornecida. É a forma idiomática de lidar com casos onde a ausência de valor é um erro.

// Obtém o nome ou "Convidado" como padrão
String name = absentName.orElse("Convidado");

// Obtém o nome ou gera um nome aleatório (operação custosa)
String complexName = absentName.orElseGet(() -> "User" + new java.util.Random().nextInt());

// Exige que o valor exista, caso contrário, lança uma exceção
String requiredName = presentName.orElseThrow(() -> new IllegalStateException("O nome é obrigatório"));

3. Transformando Valores com map e filter

Quando usar: Esta é a abordagem mais flexível. Use-a quando precisar realizar operações no valor contido, sem sair da "zona de segurança" do Optional.

• map(function): Se o valor estiver presente, aplica a função a ele e retorna o resultado em um novo Optional.
• filter(predicate): Se o valor estiver presente e atender à condição, retorna um Optional com o valor; caso contrário, retorna um Optional vazio.

Esses métodos podem ser encadeados para criar pipelines de processamento elegantes e seguros.

Vamos demonstrar o pipeline com um exemplo conciso que você pode rodar e testar.

import java.util.Map;
import java.util.Optional;

// Usando um record para uma definição de classe concisa
record User(String name, String avatarUrl) {}

public class OptionalPipelineExample {

    // Simula uma busca em um "banco de dados"
    public static Optional<User> findUserById(int id) {
        Map<Integer, User> userDatabase = Map.of(
            1, new User("Ana", "http://example.com/ana.jpg"),
            2, new User("Beto", ""),      // URL de avatar vazia
            3, new User("Carla", null)    // URL de avatar nula
        );
        return Optional.ofNullable(userDatabase.get(id));
    }

    // O nosso pipeline de processamento
    public static String getUserAvatarInitial(int userId) {
        return findUserById(userId) // Retorna Optional<User>
               .map(User::avatarUrl) // Transforma em Optional<String> (URL)
               .filter(url -> url != null && !url.isEmpty()) // Garante que a URL não é nula nem vazia
               .map(url -> url.substring(0, 1).toUpperCase()) // Pega a primeira letra e a torna maiúscula
               .orElse("?"); // Se em qualquer passo o Optional ficar vazio, retorna "?"
    }

    public static void main(String[] args) {
        System.out.println("Inicial do avatar (ID 1): " + getUserAvatarInitial(1)); // Saída: H
        System.out.println("Inicial do avatar (ID 2): " + getUserAvatarInitial(2)); // Saída: ?
        System.out.println("Inicial do avatar (ID 3): " + getUserAvatarInitial(3)); // Saída: ?
        System.out.println("Inicial do avatar (ID 99): " + getUserAvatarInitial(99)); // Saída: ?
    }
}

Neste exemplo, não há uma única verificação de null. A lógica flui de forma segura através do pipeline.

Conclusão: Um Guia de Decisão

• Para criar um Optional: Use Optional.ofNullable() na maioria das vezes.
• Para executar uma ação: Use ifPresent() ou ifPresentOrElse().
• Para obter um valor com um fallback: Use orElse() para valores simples ou orElseGet() para valores de fallback custosos.
• Se a ausência é um erro: Use orElseThrow().
• Para encadear lógica de forma segura: Use map() e filter().
• Quando usar get()? Quase nunca. Prefira os métodos acima.