Java optional: descubre cómo evitar NullPointerException con elegancia

Uno de los errores más temidos y frustrantes en programación es el NullPointerException o NPE. Este ocurre cuando intentamos acceder a un objeto que no existe o tiene un valor nulo. Este error llegó a ser tan común en Java, que los programadores siempre debían estar haciendo comprobaciones para evitarlo. Por fortuna, gracias a la llegada de Java 8 apareció una solución simple, el Java optional. En este artículo te contaremos qué es Java optional y cómo usarlo para evitar errores como el mencionado.

¿Qué es Java Optional?

Java optional es una clase que funciona como contenedor para un valor que puede estar presente o no. Este contenedor nos brinda una opción clara y segura para manejar valores nulos sin tener que comprobar constantemente si una variable es nula. Con Java optional, en lugar de lanzar un NullPointerException, puedes trabajar con valores opcionales de manera más fluida y controlada.

Así pues, tenemos que, básicamente, Java optional es un tipo de dato que puede contener un objeto o estar vacío, esto nos permite evitar las comprobaciones de null de manera reiterativa.

Una de las razones de más peso para hacer uso de Java optional es evitar esos molestos NullPointerException que pueden surgir si intentamos acceder a métodos o propiedades de un objeto que es nulo. Gracias a esta clase, no es necesario escribir condicionales cada vez que queramos comprobar si un valor es nulo o no.

¿Cómo crear un Java Optional?

No hay una sola forma de crear un java optional, veamos unas cuantas de las que existen:

Crear un Optional vacío:

Optional<String> emptyOptional = Optional.empty();

En este caso, con esta línea de código creamos un optional vacío, lo que quiere decir que no contiene ningún valor. Es usado cuando se quiere devolver algo que claramente no tiene valor, sin tener que recurrir a null.

Crear un Optional con un valor:

Optional<String> nameOptional = Optional.of("Pedro");

Este ejemplo crea un Optional que contiene el valor “Pedro”. Si intentas crear un Optional con un valor nulo usando este método, obtendrás una excepción.

Crear un Optional que puede ser nulo:

Optional<String> maybeName = Optional.ofNullable(null);

Este método es similar a of(), pero permite que el valor sea nulo. Si el valor es null, devuelve un Optional vacío.

¿Cómo trabajar con Java Optional?

Una vez creado el Java optional, la forma en la que se accede a su valor es distinta a como se haría con una variable normal. Veamos este proceso con ejemplos:

Comprobar si un valor está presente

if (nameOptional.isPresent()) {
    System.out.println(nameOptional.get());
}

El método isPresent() nos permite hacer una verificación respecto a un valor, si este está presente dentro del optional. Si está presente, se puede obtener el valor con get(). No obstante, este enfoque sigue requiriendo un condicional, lo cual no es práctico ni óptimo.

Usar ifPresent() para evitar condicionales

Una mejor alternativa a isPresent() es usar ifPresent():

nameOptional.ifPresent(name -> System.out.println(name));

Este método ejecuta una función solo si el valor está presente, evitando la necesidad de comprobar el valor con un if.

Proporcionar un valor por defecto con orElse()

A veces, necesitas asegurarte de que siempre haya un valor, incluso si el Optional está vacío. En este caso, puedes usar orElse():

String name = nameOptional.orElse("Desconocido");

Si el Optional contiene un valor, lo devuelve. Si está vacío, se devuelve el valor por defecto, en este caso, “Desconocido”.

Ejemplo: buscando notas

Imagina que estás buscando una nota sobresaliente en una lista de notas. Sin Optional, tendrías que manejar los valores nulos manualmente:

public static Nota buscarNotaSobresaliente(List<Nota> notas) {
    for (Nota unaNota : notas) {
        if (unaNota.getValor() >= 9) {
            return unaNota;
        }
    }
    return null;
}

Esto requiere que compruebes si el valor es null cada vez que lo llamas. Con Java Optional, este código se simplifica mucho:

public static Optional<Nota> buscarNotaSobresaliente(List<Nota> notas) {
    return notas.stream()
            .filter(nota -> nota.getValor() >= 9)
            .findFirst();
}

Ahora, puedes trabajar con el Optional de manera más clara:

Optional<Nota> notaSobresaliente = buscarNotaSobresaliente(notas);
notaSobresaliente.ifPresent(nota -> System.out.println("Nota sobresaliente: " + nota.getValor()));

Evitar errores con orElseThrow

A veces, quieres que se lance una excepción si el Optional está vacío. Para eso puedes usar orElseThrow():

Nota nota = notaSobresaliente.orElseThrow(() -> new RuntimeException("No hay notas sobresalientes"));

Es usado en casos en los que esperas que el valor esté presente y consideras una ausencia de valor como una situación excepcional.

Si te interesó el tema sobre Java y quieres seguir aprendiendo sobre este interesante lenguaje, no dudes en escribirnos para preguntar por el bootcamp java que tenemos en Keepcoding para ti. Aquí aprenderás las habilidades necesarias para transformar una carrera exitosa. ¡No te lo pierdas!