Siempre se ha sabido que no podemos acelerarnos a la hora de manejar valores nulos en Java, porque es una tarea sumamente delicada. Pensando en eso, Optional.ofNullable() en Java 8 llegó para simplificarnos un poco las cosas, sobre todo al momento de trabajar con valores que podrían ser nulos de manera más segura y limpia. Tengo para ti estos ejemplos y casos prácticos con los que aprenderás a usar este método fácilmente.

¿Qué encontrarás en este post?

¿Qué es Optional.ofNullable() en Java?

Optional.ofNullable() en Java es un método con el que puedes envolver un valor dentro de un “contenedor especial” conocido como optional. Gracias a ese contenedor podrás trabajar de forma segura con valores que podrían ser nulos.

Lo bueno es que si el valor es nulo, no obtendrás un error, sino un Optional vacío. De esta forma puedes trabajar seguro con valores que podrían no estar presentes y no tendrás que toparte con el temido NullPointerException.

Sintaxis básica

public static <T> Optional<T> ofNullable(T value)

Parámetro: Este es el que acepta un valor de tipo T que puede ser nulo.
Retorno: Aquí verás que se devuelve un objeto Optional que contiene el valor especificado o, si el valor es nulo, un Optional.empty.

¿Cómo funciona Optional.ofNullable() en Java? Ejemplos y casos prácticos

El método Optional.ofNullable() en Java es excelente cuando se trata de manejar situaciones en las que no estamos seguros de si un valor estará presente. He preparado estos ejemplos para explicártelo mejor:

Encapsula un valor no nulo

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> nombre = Optional.ofNullable("KeepCoding");

        System.out.println("Optional contiene: " + nombre.orElse("Valor por defecto"));
    }
}

La salida te saldrá así:
Optional contiene: KeepCoding

¿Qué notaste aquí? Cuando el valor no es nulo, Optional.ofNullable() lo encapsula, por eso es que podemos acceder a él con métodos como orElse().

Encapsula un valor nulo

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> nombre = Optional.ofNullable(null);

        System.out.println("Optional contiene: " + nombre.orElse("Valor por defecto"));
    }
}

Préstale atención a esta salida:
Optional contiene: Valor por defecto

En este caso, dado que el valor inicial es nulo, el Optional está vacío y se utiliza el valor alternativo proporcionado por orElse().

Usa ifPresent() para acciones específicas

Te sorprenderá saber que con Optional.ofNullable() en Java, puedes ejecutar acciones si el valor está presente o ignorarlas si no lo está.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        Optional<String> correo = Optional.ofNullable("[email protected]");

        correo.ifPresent(valor -> System.out.println("Correo: " + valor));
    }
}

Mira la salida:
Correo: [email protected]

¿Qué pasaría si el valor fuera nulo? pues sencillo, no se imprimiría nada y no existiría la necesidad de hacer verificaciones manuales.

Uso con colecciones

Para este caso quiero que pienses que tienes una lista de productos y quieres encontrar uno específico:

import java.util.Optional;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> productos = Arrays.asList("Laptop", "Teclado", "Mouse");

        Optional<String> producto = productos.stream()
                                              .filter(p -> p.equals("Mouse"))
                                              .findFirst();

        System.out.println(producto.orElse("Producto no encontrado"));
    }
}

Esta sería la salida:
Mouse

Como ves, si el producto no estuviera en la lista, se imprimiría el mensaje alternativo.

Combinación con métodos de transformación

Te muestro que también puedes usar map() junto con Optional.ofNullable() en Java para transformar valores de manera segura.

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String nombre = "KeepCoding";
        
        Optional<String> mayusculas = Optional.ofNullable(nombre)
                                              .map(String::toUpperCase);

        System.out.println("En mayúsculas: " + mayusculas.orElse("Valor vacío"));
    }
}

Salida:
En mayúsculas: KEEPCODING

¿Te diste cuenta? Si nombre fuera nulo, obtendríamos Valor vacío.

Diferencias clave entre Optional.of() y Optional.ofNullable() en Java

Optional.of(): Es el que lanza una NullPointerException si el valor proporcionado es nulo. Úsalo cuando estás seguro de que el valor no será nulo.
Optional.ofNullable(): Este permite que el valor sea nulo y devuelve un Optional.empty en ese caso. Es la opción más segura cuando hay incertidumbre sobre los valores.

Buenas prácticas con Optional.ofNullable() en Java

Evita el uso excesivo: No encapsules valores simples o primitivos en Optional sin motivo.
Combina métodos eficientemente: Usa orElse(), map() o ifPresent() para manejar los valores encapsulados.
Evita Optional en atributos de clase: Úsalo principalmente en métodos para devolver resultados opcionales.

Que bueno que ya te diste cuenta de que con Optional.ofNullable() trabajarás de manera segura con valores nulos, reduciendo errores y haciendo tu código más limpio. Desde la encapsulación de valores hasta la transformación y verificación, este método te brinda soluciones eficaces.

Conoce más de Java en el Bootcamp de Java Full Stack de KeepCoding, donde aprenderás todo lo necesario para dominar este lenguaje, desde lo básico hasta conceptos avanzados como Streams y Optional. ¡Apúntate ahora y transforma tu carrera en tecnología en tiempo récord!