En mis inicios programando con Java, quienes tenían más experiencia siempre me decían que tuviese cuidado, porque algún día me encontraría con un NullPointerException y efectivamente así fue. Un día trabajando en un proyecto, me dio por ejecutar el código y el flujo se rompió, quedé atónito porque no sabía de dónde provenía el error o cómo lo podía evitar en un futuro. Me explicaron que java.util.Optional me serviría para combatir estos errores molestos y escribir un mejor código. Así que, como no quiero ser egoísta, te compartiré lo que yo aprendí y los tips que me sirvieron en estas situaciones.
¿Qué es java.util.Optional?
Java.util.Optional es como una caja de regalo que puede contener una sorpresa o simplemente estar vacía. De modo que, es una caja diseñada para contener un valor que puede estar presente (un regalo) o ausente (caja vacía).
Entonces, java.util.Optional es una clase genérica que actúa como un contenedor para un valor que puede o no estar presente. Es una alternativa segura para manejar referencias nulas y prevenir errores como el NullPointerException.
Puedes entenderlo así:
- Optional: Te decía que es la caja de regalo que puede o no contener un valor.
- Verificar si hay un valor: Puedes revisar si la caja contiene un regalo, similar a cómo puedes verificar si un Optional contiene un valor.
- Obtener el valor: Si la caja tiene un regalo, puedes abrirla y sacar el regalo, igual que cómo obtienes el valor de un Optional si está presente.
¿Cómo crear objetos Optional?
Primero quiero mostrarte que existen tres formas principales de crear un objeto Optional:
Optional.empty()
Así es como puedes crear un Optional vacío sin ningún valor asociado.
Optional<String> emptyOptional = Optional.empty();Optional.ofNullable()
Con Optional.ofNullable() crearás un Optional que puede contener un valor o ser nulo.
String value = null;
Optional<String> nullableOptional = Optional.ofNullable(value);Optional.of()
Con Optional.of() crearás un Optional que contiene un valor no nulo. Recuerda muy bien que, si el valor es nulo, lanza una excepción.
String value = "Hello, Java!";
Optional<String> nonNullableOptional = Optional.of(value);Métodos clave de java.util.Optional que debes conocer
Una vez entendido lo anterior, ahora quiero que conozcas los métodos más importantes de java.util.Optional, porque solo así aprenderás cómo se usa correctamente.
isPresent()
Gracias a este método puedes verificar si el Optional contiene un valor.
Optional<String> optionalValue = Optional.of("KeepCoding");
if (optionalValue.isPresent()) {
System.out.println("Valor: " + optionalValue.get());
}ifPresent()
Con este método se ejecuta una acción si el valor está presente.
optionalValue.ifPresent(value -> System.out.println("Valor presente: " + value));orElse()
Vas a ver que este método te devuelve un valor por defecto si el Optional está vacío.
String result = optionalValue.orElse("Valor por defecto");
System.out.println(result);orElseGet()
Lo que hace este método es proporcionarte un valor por defecto calculado mediante una función.
String result = optionalValue.orElseGet(() -> "Valor calculado");
System.out.println(result);orElseThrow()
Este método se encarga de lanzar una excepción si el valor no está presente.
String result = optionalValue.orElseThrow(() -> new RuntimeException("Valor ausente"));map()
Podrás ver cómo este método transforma el valor contenido dentro del Optional si está presente.
Optional<String> upperCaseValue = optionalValue.map(String::toUpperCase);
upperCaseValue.ifPresent(System.out::println);filter()
Como su nombre lo dice, filtra el valor dentro del Optional basado en una condición.
Optional<String> filteredValue = optionalValue.filter(value -> value.startsWith("Keep"));
filteredValue.ifPresent(System.out::println);Cómo usar java.util.Optional: Ejemplo práctico
Para este ejemplo supón que tienes un sistema que obtiene información de un cliente:
public class Cliente {
private String nombre;
public Cliente(String nombre) {
this.nombre = nombre;
}
public String getNombre() {
return nombre;
}
}
public Optional<Cliente> obtenerClientePorId(String id) {
return id.equals("123") ? Optional.of(new Cliente("Juan")) : Optional.empty();
}
public static void main(String[] args) {
Optional<Cliente> cliente = obtenerClientePorId("123");
String nombre = cliente.map(Cliente::getNombre).orElse("Cliente no encontrado");
System.out.println(nombre);
}Si observas bien, puedes notar que evitamos verificar manualmente si el cliente existe y proporcionamos un valor por defecto. Por eso te digo que es muy sencillo de usar.
Consejos al momento de usar java.util.Optional
- No uses Optional para campos o variables de clase: Lo que a mí me sirvió fue limitar su uso a retornos de métodos.
- Evita lo que más puedas el uso de get() sin verificar si el valor está presente: Es mejor que optes por métodos como ifPresent() o orElse().
- Usa Optional para mejorar la legibilidad: Este tip me encanta, yo combino métodos como map() y filter() para evitar verificaciones manuales de nulos y me ha funcionado muy bien.
Si quieres dominar Java y llevar tus habilidades al siguiente nivel, el Bootcamp de Java Full Stack de KeepCoding es para ti. Aprenderás a resolver problemas reales, como evitar errores de nulidad, y te prepararás para trabajar en el emocionante mundo de la tecnología. ¡Empieza hoy y da el primer paso hacia una carrera IT exitosa!
