¿Cómo usar Optional.of() en Java? Ejemplos y guía práctica

No sé si soy el único, pero me ha pasado que quiero evitar a toda cosa encontrarme con esos valores nulos en Java. Uno se encuentra con NullPointerException, un problema que causa errores muy difíciles de rastrear y hasta ahí nos llega el día trabajando. Yo encontré una solución más práctica y es con Optional.of() en Java. La verdad es una mejor manera de manejar valores opcionales y no hay que hacer un uso excesivo de verificaciones manuales con null.

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

Optional.of() en Java es un método estático de la clase Optional que se utiliza para crear una instancia de Optional a partir de un valor no nulo. Esto significa que puedes encapsular un valor dentro de un Optional y manejarlo de una manera más segura, sin temor a encontrarte con esas excepciones inesperadas.

Sintaxis básica

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

• Parámetro: Aquí se recibe un valor de tipo T (cualquier objeto no nulo).
• Retorno: Es el que devuelve un objeto Optional que contiene el valor especificado.
• Excepción: Se encarga de lanzar NullPointerException si el valor proporcionado es null.

Puede que ahora te suene un poco complejo, por eso he creado unos ejemplos prácticos para que entiendas bien cómo usar Optional.of() en Java en diferentes situaciones.

¿Cómo usar Optional.of() en Java? Ejemplos prácticos

Creando un Optional con un valor válido

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        // Crear un Optional con un valor válido
        Optional<String> nombre = Optional.of("KeepCoding");
        
        // Imprimir el contenido del Optional
        System.out.println("Optional contiene: " + nombre.get());
    }
}

Salida:
Optional contiene: KeepCoding

¿Te diste cuenta? En este caso, el método get() extrae el valor encapsulado en el Optional.

Qué pasa si usas un valor nulo

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        try {
            // Intentar crear un Optional con un valor nulo
            Optional<String> opcionalNulo = Optional.of(null);
        } catch (NullPointerException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Observa esta salida:
Error: null

Lo que pasa aquí es que, Optional.of() lanza una NullPointerException porque no permite valores nulos. Entonces, si necesitas manejar valores nulos, lo mejor es que uses Optional.ofNullable().

Usa Optional para evitar NullPointerException

Quiero que imagines que tienes un método que retorna datos de un usuario:

public String obtenerNombreUsuario() {
    return "Juan Pérez"; // Puede retornar null en otros casos
}

Mi consejo es que, en lugar de trabajar directamente con este valor, lo encapsules en un Optional:

import java.util.Optional;

public class Main {
    public static void main(String[] args) {
        String nombre = "Juan Pérez";

        Optional<String> optionalNombre = Optional.of(nombre);

        optionalNombre.ifPresentOrElse(
            valor -> System.out.println("El nombre es: " + valor),
            () -> System.out.println("No se proporcionó ningún nombre.")
        );
    }
}

La salida te queda así:
El nombre es: Juan Pérez

Con ifPresentOrElse(), puedes realizar una acción si el valor está presente o ejecutar una alternativa si no lo está.

Uso práctico con colecciones

En este caso piensa que tienes una lista de productos, y necesitas obtener el primero que coincida con un criterio específico:

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

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

        // Buscar el primer producto que comience con "L"
        Optional<String> producto = productos.stream()
                                             .filter(p -> p.startsWith("L"))
                                             .findFirst();

        producto.ifPresentOrElse(
            p -> System.out.println("Producto encontrado: " + p),
            () -> System.out.println("No se encontró ningún producto.")
        );
    }
}

Mira la salida:
Producto encontrado: Laptop

Consejos a la hora de usar Optional.of() en Java

1. No uses Optional para todo: Tampoco abuses. Aunque es útil, no es necesario encapsular valores simples como boolean o números primitivos.
2. Evita Optional en atributos de clase: Mi consejo aquí es que mejor lo uses solo en valores retornados por métodos.
3. Usa Optional.ofNullable() para valores inciertos: En caso tal de que creas que existe la posibilidad de que un valor sea null, considera usar esta variante.

Creo que te he dejado claro que Optional.of() en Java es una muy buena herramienta para evitar errores comunes relacionados con valores nulos. Ya viste que al implementarla obtienes un código más limpio, seguro y fácil de mantener. Con los ejemplos prácticos que te mostré, espero que lo empieces a aplicar hoy mismo.

¿Te gustan estos temas? Tengo una buena noticia para ti, ¡ya estás listo para dar el siguiente paso! En el Bootcamp de Java Full Stack de KeepCoding, aprenderás a dominar todos los conceptos de Java, desde fundamentos hasta herramientas avanzadas, preparándote para una carrera IT en tiempo récord. ¡Apúntate ahora y transforma tu futuro!