Propósito y creación de Optional

La clase Optional se introdujo en Java para solucionar el manejo de valores nulos. Antes de su existencia, se utilizaban comprobaciones explícitas de nulos que resultaban en código verboso y propenso a errores. El propósito fundamental de Optional es proporcionar un contenedor que puede o no contener un valor no nulo, haciendo explícita la posibilidad de ausencia de valor.

Al utilizar Optional, se comunica la intención del código: un método puede no devolver un resultado válido, y esto debe manejarse adecuadamente.

Para crear instancias de Optional, se dispone de varios métodos estáticos:

// Crear un Optional vacío
Optional<String> optionalVacio = Optional.empty();

// Crear un Optional con un valor no nulo
String nombre = "Java";
Optional<String> optionalConValor = Optional.of(nombre);

// Crear un Optional que puede contener un valor nulo
String valorPosiblementeNulo = obtenerValor(); // podría ser null
Optional<String> optionalSeguro = Optional.ofNullable(valorPosiblementeNulo);

El método Optional.of() requiere un valor no nulo y lanzará una NullPointerException si se le pasa null. Por otro lado, Optional.ofNullable() acepta valores nulos, creando un Optional vacío en ese caso. Esta distinción es crucial para entender cuándo usar cada método.

Se puede verificar si un Optional contiene un valor mediante el método isPresent():

Optional<String> optionalNombre = Optional.ofNullable(obtenerNombreUsuario());

if (optionalNombre.isPresent()) {
    System.out.println("Nombre encontrado: " + optionalNombre.get());
} else {
    System.out.println("Nombre no disponible");
}

También se dispone del método isEmpty() que realiza la comprobación inversa:

if (optionalNombre.isEmpty()) {
    System.out.println("No se encontró ningún nombre");
}

Un caso de uso típico para Optional es en métodos que realizan búsquedas y pueden no encontrar resultados:

public Optional<Usuario> buscarPorId(long id) {
    Usuario usuario = repositorio.encontrarUsuario(id);
    return Optional.ofNullable(usuario);
}

Este enfoque es superior a devolver null o lanzar excepciones para casos normales donde no encontrar un resultado es una situación esperada.

Para entender mejor el propósito de Optional, se puede examinar un ejemplo práctico donde se evita la comprobación anidada de nulos:

// Código tradicional propenso a NullPointerException
public String obtenerCiudadDelUsuario(Usuario usuario) {
    if (usuario != null) {
        Direccion direccion = usuario.getDireccion();
        if (direccion != null) {
            return direccion.getCiudad();
        }
    }
    return "Desconocida";
}

// Usando Optional para el mismo propósito
public String obtenerCiudadDelUsuario(Usuario usuario) {
    return Optional.ofNullable(usuario)
            .map(Usuario::getDireccion)
            .map(Direccion::getCiudad)
            .orElse("Desconocida");
}

El segundo enfoque es más conciso, declarativo y menos propenso a errores. Además, expresa claramente la intención del código.

Optional no está diseñado para ser usado como campo de clase o parámetro de método en la mayoría de los casos. Su uso principal se centra en ser un tipo de retorno para métodos que podrían no producir un resultado. La clase no implementa Serializable, lo que limita su uso en ciertos contextos.

// No recomendado
public class Usuario {
    private Optional<String> correoElectronico; // Evitar esto
}

// Recomendado
public class Usuario {
    private String correoElectronico; // Puede ser null
    
    public Optional<String> getCorreoElectronico() {
        return Optional.ofNullable(correoElectronico);
    }
}

Al crear instancias de Optional, se debe considerar el contexto y elegir el método adecuado:

• Se usa Optional.empty() cuando se necesita un Optional vacío explícitamente.
• Se utiliza Optional.of(valor) cuando se tiene la certeza de que el valor no es nulo.
• Se emplea Optional.ofNullable(valor) cuando el valor podría ser nulo.

Métodos de acceso: get(), orElse(), orElseGet()

Una vez creado un Optional, se necesitan formas seguras de extraer o trabajar con el valor contenido. Java proporciona varios métodos de acceso que permiten obtener el valor de un Optional de manera controlada y evitando excepciones inesperadas.

El método más básico es get(), que devuelve el valor si está presente, pero lanza una excepción si el Optional está vacío:

Optional<String> optionalNombre = Optional.of("Ana");
String nombre = optionalNombre.get(); // Devuelve "Ana"

Optional<String> optionalVacio = Optional.empty();
// La siguiente línea lanzará NoSuchElementException
String valorInexistente = optionalVacio.get();

Debido a que get() puede lanzar una excepción, se recomienda verificar primero si existe un valor mediante isPresent():

Optional<String> optionalNombre = obtenerNombreUsuario();
if (optionalNombre.isPresent()) {
    String nombre = optionalNombre.get(); // Seguro, ya verificamos
    System.out.println("Nombre: " + nombre);
}

Sin embargo, este enfoque no aprovecha el estilo funcional que Optional promueve. Para un código más menos propenso a errores, se pueden utilizar métodos alternativos como orElse():

Optional<String> optionalNombre = obtenerNombreUsuario();
String nombre = optionalNombre.orElse("Invitado");

El método orElse() devuelve el valor contenido si está presente, o el valor alternativo proporcionado si el Optional está vacío. Este patrón es muy útil para establecer valores predeterminados:

public String obtenerNombreUsuario(long id) {
    return repositorioUsuarios.buscarPorId(id)
            .map(Usuario::getNombre)
            .orElse("Usuario no encontrado");
}

Una característica importante de orElse() es que el valor alternativo se evalúa siempre, incluso cuando el Optional contiene un valor. Esto puede ser ineficiente si la creación del valor alternativo es costosa:

// El método generarNombreAleatorio() se ejecuta siempre,
// incluso cuando optionalNombre tiene un valor
String nombre = optionalNombre.orElse(generarNombreAleatorio());

Para evitar este problema, se puede utilizar orElseGet(), que acepta un Supplier (proveedor de valores) y solo lo ejecuta cuando el Optional está vacío:

// generarNombreAleatorio() solo se ejecuta si optionalNombre está vacío
String nombre = optionalNombre.orElseGet(() -> generarNombreAleatorio());
// O usando referencia a método
String nombre = optionalNombre.orElseGet(this::generarNombreAleatorio);

La diferencia entre orElse() y orElseGet() se hace más evidente en el siguiente ejemplo:

public String ejemploOrElse(Optional<String> optionalValor) {
    System.out.println("Evaluando orElse...");
    return optionalValor.orElse(obtenerValorPorDefecto());
}

public String ejemploOrElseGet(Optional<String> optionalValor) {
    System.out.println("Evaluando orElseGet...");
    return optionalValor.orElseGet(this::obtenerValorPorDefecto);
}

private String obtenerValorPorDefecto() {
    System.out.println("Generando valor por defecto...");
    // Simulamos una operación costosa
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Valor predeterminado";
}

Si llamamos a estos métodos con un Optional que contiene un valor:

Optional<String> conValor = Optional.of("Hola");
ejemploOrElse(conValor);      // Imprime: "Evaluando orElse..." y "Generando valor por defecto..."
ejemploOrElseGet(conValor);   // Solo imprime: "Evaluando orElseGet..."

Para casos donde se necesita lanzar una excepción cuando el Optional está vacío, se puede utilizar orElseThrow():

String nombre = optionalNombre.orElseThrow(() -> 
    new UsuarioNoEncontradoException("No se encontró el usuario con ID: " + id));

A partir de Java 10, existe una versión simplificada de orElseThrow() que lanza NoSuchElementException sin necesidad de especificar la excepción:

String nombre = optionalNombre.orElseThrow(); // Lanza NoSuchElementException si está vacío

Para casos donde solo se necesita ejecutar una acción si el valor está presente, se puede utilizar ifPresent():

optionalUsuario.ifPresent(usuario -> 
    System.out.println("Usuario encontrado: " + usuario.getNombre()));

Y desde Java 9, se dispone de ifPresentOrElse() que permite especificar acciones tanto para cuando el valor está presente como para cuando no lo está:

optionalUsuario.ifPresentOrElse(
    usuario -> System.out.println("Usuario encontrado: " + usuario.getNombre()),
    () -> System.out.println("Usuario no encontrado")
);

La elección del método de acceso adecuado depende del contexto y de los requisitos específicos:

• get(): Solo cuando se tiene la certeza de que el valor existe.
• orElse(): Para valores alternativos simples o precalculados.
• orElseGet(): Para valores alternativos que son costosos de calcular.
• orElseThrow(): Cuando la ausencia de valor debe tratarse como una excepción.
• ifPresent() e ifPresentOrElse(): Para ejecutar acciones sin necesidad de extraer el valor.

Un ejemplo práctico que combina varios de estos métodos sería:

public void procesarPedido(long idPedido) {
    repositorioPedidos.buscarPorId(idPedido)
        .ifPresentOrElse(
            pedido -> {
                String nombreCliente = pedido.getCliente()
                    .map(Cliente::getNombre)
                    .orElse("Cliente sin nombre");
                
                String direccionEntrega = pedido.getDireccionEntrega()
                    .orElseGet(() -> pedido.getCliente()
                        .flatMap(Cliente::getDireccionPredeterminada)
                        .orElseThrow(() -> new DatosFaltantesException("No hay dirección de entrega")));
                
                servicioEntrega.programarEntrega(pedido, direccionEntrega);
                System.out.println("Pedido de " + nombreCliente + " procesado correctamente");
            },
            () -> System.out.println("No se encontró el pedido con ID: " + idPedido)
        );
}

Operaciones funcionales: map(), flatMap(), filter()

La clase Optional no solo ofrece métodos para acceder a sus valores, sino también operaciones funcionales que permiten transformar y filtrar su contenido de manera declarativa. Estas operaciones siguen el patrón de diseño de la programación funcional, permitiendo encadenar múltiples transformaciones sin necesidad de verificaciones explícitas de nulidad.

Las tres operaciones funcionales principales de Optional son map(), flatMap() y filter(). Estas operaciones se ejecutan solo cuando el Optional contiene un valor, y devuelven otro Optional como resultado, lo que facilita su encadenamiento.

El método map() permite transformar el valor contenido en un Optional aplicando una función, y devuelve el resultado envuelto en otro Optional:

Optional<String> optionalNombre = Optional.of("María");
Optional<Integer> longitudNombre = optionalNombre.map(String::length);
// longitudNombre contiene Optional[5]

Si el Optional original está vacío, map() simplemente devuelve un Optional vacío sin ejecutar la función:

Optional<String> optionalVacio = Optional.empty();
Optional<Integer> resultado = optionalVacio.map(String::length);
// resultado es Optional.empty()

Esta característica es útil para navegar por cadenas de objetos sin preocuparse por valores nulos:

// Obtener el código postal de un usuario de forma segura
Optional<String> codigoPostal = Optional.ofNullable(usuario)
    .map(Usuario::getDireccion)
    .map(Direccion::getCodigoPostal);

El método flatMap() se utiliza cuando la función de transformación ya devuelve un Optional. A diferencia de map(), que envolvería ese resultado en otro Optional (creando un Optional<Optional<T>>), flatMap() "aplana" el resultado para evitar el anidamiento:

// Método que ya devuelve un Optional
public Optional<Telefono> obtenerTelefonoPrincipal(Usuario usuario) {
    return Optional.ofNullable(usuario.getTelefonos())
        .filter(telefonos -> !telefonos.isEmpty())
        .map(telefonos -> telefonos.get(0));
}

// Uso con map() (incorrecto)
Optional<Optional<Telefono>> telefonoAnidado = Optional.ofNullable(usuario)
    .map(this::obtenerTelefonoPrincipal);

// Uso con flatMap() (correcto)
Optional<Telefono> telefono = Optional.ofNullable(usuario)
    .flatMap(this::obtenerTelefonoPrincipal);

El método flatMap() es esencial cuando se trabaja con métodos que ya devuelven Optional, como en este ejemplo de navegación por una estructura de objetos:

public Optional<String> obtenerNombreEmpresa(long idUsuario) {
    return repositorioUsuarios.buscarPorId(idUsuario)  // Devuelve Optional<Usuario>
        .flatMap(Usuario::getDepartamento)            // Método que devuelve Optional<Departamento>
        .flatMap(Departamento::getEmpresa)            // Método que devuelve Optional<Empresa>
        .map(Empresa::getNombre);                     // Transformación simple
}

El método filter() permite aplicar un predicado (una función que devuelve un booleano) al valor contenido en el Optional. Si el predicado devuelve true, el Optional se mantiene igual; si devuelve false o el Optional estaba vacío, se devuelve un Optional vacío:

Optional<Integer> numero = Optional.of(42);

// El número es par, el filtro pasa
Optional<Integer> numeroPar = numero.filter(n -> n % 2 == 0);
// numeroPar sigue siendo Optional[42]

// El número no es mayor que 100, el filtro no pasa
Optional<Integer> numeroGrande = numero.filter(n -> n > 100);
// numeroGrande es Optional.empty()

El método filter() es particularmente útil para validar condiciones antes de procesar un valor:

public void procesarPedido(Optional<Pedido> optionalPedido) {
    optionalPedido
        .filter(Pedido::estaPagado)
        .filter(pedido -> !pedido.getProductos().isEmpty())
        .ifPresentOrElse(
            this::enviarPedido,
            () -> System.out.println("El pedido no cumple los requisitos para ser enviado")
        );
}

Estas tres operaciones funcionales se pueden combinar para crear flujos de procesamiento complejos:

public Optional<Double> calcularDescuentoUsuarioPremium(long idUsuario) {
    return repositorioUsuarios.buscarPorId(idUsuario)
        .filter(Usuario::esPremium)                       // Solo usuarios premium
        .filter(usuario -> usuario.getAntiguedadAnios() > 2)  // Con más de 2 años
        .flatMap(Usuario::getUltimaCompra)                // Obtener última compra (Optional)
        .filter(compra -> compra.getTotal() > 1000)       // Solo compras grandes
        .map(compra -> compra.getTotal() * 0.15);         // Calcular 15% de descuento
}

Un caso de uso común es la validación de entrada de datos, donde se pueden encadenar múltiples condiciones:

public Optional<Usuario> validarYCrearUsuario(String nombre, String email, int edad) {
    return Optional.ofNullable(nombre)
        .filter(n -> !n.trim().isEmpty())
        .flatMap(n -> Optional.ofNullable(email)
            .filter(e -> e.contains("@"))
            .filter(e -> e.length() > 5)
            .flatMap(e -> edad >= 18 
                ? Optional.of(new Usuario(n, e, edad))
                : Optional.empty()
            )
        );
}

Para entender mejor cómo funcionan estas operaciones juntas, veamos un ejemplo práctico de un sistema de procesamiento de pedidos:

public class SistemaPedidos {
    
    public Optional<String> generarResumenEnvio(long idPedido) {
        return repositorioPedidos.buscarPorId(idPedido)
            // Verificar que el pedido esté confirmado
            .filter(Pedido::estaConfirmado)
            // Obtener la dirección de envío (que podría ser Optional)
            .flatMap(pedido -> pedido.getDireccionEnvio()
                // Si no hay dirección de envío, intentar con la del cliente
                .or(() -> pedido.getCliente()
                    .flatMap(Cliente::getDireccionPrincipal))
            )
            // Transformar la dirección en un resumen formateado
            .map(direccion -> String.format(
                "Envío a: %s, %s, %s, %s",
                direccion.getCalle(),
                direccion.getCiudad(),
                direccion.getCodigoPostal(),
                direccion.getPais()
            ));
    }
    
    public Optional<Double> calcularImpuestos(Pedido pedido) {
        return Optional.ofNullable(pedido)
            // Filtrar pedidos nacionales (los internacionales tienen otro cálculo)
            .filter(p -> "NACIONAL".equals(p.getTipoEnvio()))
            // Obtener los productos del pedido
            .map(Pedido::getProductos)
            // Filtrar si la lista no está vacía
            .filter(productos -> !productos.isEmpty())
            // Calcular el total de impuestos (21% del valor total)
            .map(productos -> productos.stream()
                .mapToDouble(Producto::getPrecio)
                .sum() * 0.21);
    }
}

Es importante entender las diferencias sutiles entre map() y flatMap() para usarlos correctamente:

// Estructura de datos
class Usuario {
    private String nombre;
    private Optional<Direccion> direccion; // La dirección es opcional
    
    // Getters...
    public Optional<Direccion> getDireccion() {
        return direccion;
    }
}

// Usando map() incorrectamente
Optional<Usuario> optUsuario = obtenerUsuario();
Optional<Optional<Direccion>> optOptDireccion = optUsuario.map(Usuario::getDireccion);
// Resultado: Optional<Optional<Direccion>> - anidamiento no deseado

// Usando flatMap() correctamente
Optional<Usuario> optUsuario = obtenerUsuario();
Optional<Direccion> optDireccion = optUsuario.flatMap(Usuario::getDireccion);
// Resultado: Optional<Direccion> - sin anidamiento

También se pueden combinar estas operaciones con los métodos de acceso vistos anteriormente para crear flujos de procesamiento completos:

public String procesarDatoUsuario(long idUsuario) {
    return repositorioUsuarios.buscarPorId(idUsuario)
        .filter(usuario -> usuario.getEstado() == EstadoUsuario.ACTIVO)
        .flatMap(Usuario::getPerfilPublico)
        .filter(perfil -> perfil.getVisibilidad() == Visibilidad.PUBLICO)
        .map(PerfilPublico::getResumen)
        .filter(resumen -> resumen.length() > 10)
        .map(String::toUpperCase)
        .orElse("Información no disponible");
}

Buenas prácticas y patrones de uso

Usar Optional como tipo de retorno, no como parámetro

Una de las reglas fundamentales es utilizar Optional principalmente como tipo de retorno de métodos, no como parámetro:

// Correcto: Optional como tipo de retorno
public Optional<Usuario> buscarPorEmail(String email) {
    // Implementación que puede no encontrar un usuario
    return Optional.ofNullable(baseDeDatos.buscar(email));
}

// Incorrecto: Optional como parámetro
public void procesarUsuario(Optional<Usuario> usuario) { // Evitar esto
    // Implementación
}

// Mejor alternativa
public void procesarUsuario(Usuario usuario) {
    Objects.requireNonNull(usuario, "El usuario no puede ser nulo");
    // Implementación
}

Cuando se usa Optional como parámetro, se traslada la responsabilidad de manejar la ausencia de valor al código cliente, lo que va en contra del propósito de Optional.

Evitar Optional como campo de clase

Optional no implementa la interfaz Serializable, lo que puede causar problemas si se utiliza como campo en clases que necesitan ser serializadas:

// Incorrecto
public class Usuario {
    private Optional<String> telefono; // Evitar esto
}

// Correcto
public class Usuario {
    private String telefono; // Puede ser null
    
    public Optional<String> getTelefono() {
        return Optional.ofNullable(telefono);
    }
}

Este enfoque mantiene la estructura de datos simple mientras proporciona una API segura para los clientes.

No usar Optional.get() sin verificación previa

El método get() lanza una excepción si el Optional está vacío, por lo que debe usarse con precaución:

// Peligroso: puede lanzar NoSuchElementException
Optional<String> optNombre = obtenerNombreUsuario();
String nombre = optNombre.get(); // ¡Peligro!

// Mejor enfoque: usar métodos alternativos
String nombre = optNombre.orElse("Invitado");
// O
String nombre = optNombre.orElseThrow(() -> 
    new UsuarioNoEncontradoException("No se encontró el nombre del usuario"));

Preferir métodos específicos sobre isPresent()/get()

En lugar de usar la combinación isPresent()/get(), se recomienda utilizar métodos más específicos que manejan ambos casos en una sola operación:

// Evitar este patrón
Optional<Usuario> optUsuario = repositorio.buscarPorId(id);
if (optUsuario.isPresent()) {
    return optUsuario.get().getNombre();
} else {
    return "Desconocido";
}

// Mejor enfoque
return repositorio.buscarPorId(id)
    .map(Usuario::getNombre)
    .orElse("Desconocido");

Usar orElseGet() en lugar de orElse() para operaciones costosas

Como se mencionó anteriormente, orElse() siempre evalúa su argumento, mientras que orElseGet() solo lo evalúa si el Optional está vacío:

// El método costoso se ejecuta siempre, incluso si hay un valor
return optUsuario.orElse(buscarUsuarioPorDefecto()); // Ineficiente si es costoso

// El método costoso solo se ejecuta si optUsuario está vacío
return optUsuario.orElseGet(this::buscarUsuarioPorDefecto); // Eficiente

Combinar Optional con Stream para colecciones

Cuando se trabaja con colecciones que pueden contener elementos nulos o cuando se busca un elemento que puede no existir, la combinación de Optional y Stream resulta muy efectiva:

// Encontrar el primer usuario premium con más de 100 puntos
Optional<Usuario> usuarioPremium = usuarios.stream()
    .filter(u -> u.esPremium() && u.getPuntos() > 100)
    .findFirst();

// Procesar solo si existe
usuarioPremium.ifPresent(servicioNotificaciones::enviarPromocion);

Patrón de validación en cadena

Optional permite implementar validaciones en cadena:

public Optional<Pedido> validarPedido(Pedido pedido) {
    return Optional.ofNullable(pedido)
        .filter(p -> !p.getProductos().isEmpty())
        .filter(p -> p.getCliente() != null)
        .filter(p -> p.getTotal() > 0)
        .filter(p -> p.getDireccionEntrega() != null);
}

// Uso
validarPedido(pedido).ifPresentOrElse(
    this::procesarPedido,
    () -> System.out.println("Pedido inválido")
);

Patrón de recuperación en cascada

Se puede implementar un mecanismo de "fallback" en cascada utilizando el método or() introducido en Java 9:

public Optional<Direccion> obtenerDireccionEnvio(Usuario usuario) {
    return Optional.ofNullable(usuario.getDireccionPreferida())
        .or(() -> Optional.ofNullable(usuario.getUltimaDireccionUsada()))
        .or(() -> Optional.ofNullable(usuario.getDireccionPrincipal()))
        .or(this::obtenerDireccionPorDefecto);
}

Este patrón intenta cada fuente de datos en secuencia hasta encontrar un valor no nulo.

Evitar Optional.of() con valores potencialmente nulos

Para evitar NullPointerException, se debe usar Optional.ofNullable() cuando no se tiene certeza de que el valor sea no nulo:

// Peligroso si getResultado() puede devolver null
Optional<Resultado> opt = Optional.of(servicio.getResultado());

// Seguro en todos los casos
Optional<Resultado> opt = Optional.ofNullable(servicio.getResultado());

Usar Optional para simplificar código legacy

Al integrar Optional en código existente, se puede mejorar gradualmente la seguridad y legibilidad:

// Código legacy con comprobaciones de nulos
public String obtenerDireccionFormateada(Cliente cliente) {
    if (cliente == null) return "N/A";
    Direccion dir = cliente.getDireccion();
    if (dir == null) return "Sin dirección";
    return dir.getCalle() + ", " + dir.getCiudad();
}

// Refactorizado con Optional
public String obtenerDireccionFormateada(Cliente cliente) {
    return Optional.ofNullable(cliente)
        .map(Cliente::getDireccion)
        .map(dir -> dir.getCalle() + ", " + dir.getCiudad())
        .orElse("N/A");
}

Patrón de transformación condicional

Se puede combinar filter() y map() para realizar transformaciones condicionales:

public Optional<Descuento> calcularDescuento(Pedido pedido) {
    return Optional.ofNullable(pedido)
        .filter(p -> p.getTotal() > 1000)
        .map(p -> new Descuento(p.getTotal() * 0.1, "Descuento por compra grande"));
}

Evitar Optional vacíos como indicadores de error

No se debe usar Optional.empty() para indicar errores o excepciones. Para esos casos, es mejor lanzar excepciones explícitas:

// Incorrecto: usar Optional.empty() para indicar error
public Optional<Usuario> autenticar(String usuario, String clave) {
    if (!validarCredenciales(usuario, clave)) {
        return Optional.empty(); // ¿Error de autenticación o usuario no encontrado?
    }
    return Optional.of(buscarUsuario(usuario));
}

// Mejor: ser explícito con las excepciones
public Usuario autenticar(String usuario, String clave) {
    if (!validarCredenciales(usuario, clave)) {
        throw new AutenticacionException("Credenciales inválidas");
    }
    return buscarUsuario(usuario)
        .orElseThrow(() -> new UsuarioNoEncontradoException("Usuario no encontrado: " + usuario));
}

Patrón de ejecución condicional

Para ejecutar código solo cuando se cumplan ciertas condiciones, se puede combinar filter() con ifPresent():

Optional.ofNullable(usuario)
    .filter(Usuario::esPremium)
    .filter(u -> u.getFechaUltimaCompra().isAfter(LocalDate.now().minusDays(30)))
    .ifPresent(u -> {
        enviarCorreoPromocion(u);
        actualizarEstadisticas(u);
        registrarActividad(u, "Envío de promoción");
    });

Evitar el uso excesivo de Optional

El uso excesivo de Optional puede complicar el código innecesariamente:

// Demasiado complejo para una operación simple
Optional.ofNullable(usuario)
    .map(Usuario::getNombre)
    .map(String::trim)
    .filter(nombre -> !nombre.isEmpty())
    .ifPresent(System.out::println);

// Más simple y directo para este caso
if (usuario != null && usuario.getNombre() != null) {
    String nombre = usuario.getNombre().trim();
    if (!nombre.isEmpty()) {
        System.out.println(nombre);
    }
}

Se debe evaluar cada caso y usar Optional cuando realmente aporta claridad y seguridad.

Integración con APIs de terceros

Cuando se trabaja con APIs externas que no utilizan Optional, se puede adaptar su uso:

// API externa que puede devolver null
ExternalService servicio = new ExternalService();

// Adaptación a Optional
public Optional<Resultado> consultarServicio(String consulta) {
    try {
        return Optional.ofNullable(servicio.ejecutarConsulta(consulta));
    } catch (ServiceException e) {
        logger.error("Error al consultar servicio", e);
        return Optional.empty();
    }
}

La API Optional de Java, cuando se utiliza siguiendo estas buenas prácticas, permite escribir código más robusto, expresivo y mantenible. Al adoptar un enfoque funcional para el manejo de valores ausentes, se reduce la probabilidad de errores relacionados con valores nulos y se mejora la legibilidad del código.