En varias ocasiones en las que he trabajado con Java, pude darme cuenta de que mis aplicaciones no estaban teniendo un buen rendimiento. Buscando por aquí y por allá me di cuenta de que estaba haciendo mal uso del Optional.orElse() en Java. Como no quiero que te pase lo mismo a ti, voy a explicarte qué es y cómo lo puedes usar correctamente en tus proyectos.
¿Qué es Optional.orElse() en Java?
El método Optional.orElse() en Java es una forma sencilla de asegurarte de que siempre tienes un valor, incluso si el valor original es nulo o no está presente. En otras palabras, te sirve usarlo cuando necesites un valor alternativo en caso de que el contenido del optional esté vacío.
Su firma es:
public T orElse(T other)
Aquí puedes ver que toma como argumento un valor de tipo T que se usará si el Optional no contiene ningún valor (isPresent() devuelve false). Si el valor está presente, se devuelve directamente.
¿Cómo funciona Optional.orElse() en Java?
Te decía que la idea de orElse() es darte un valor por defecto cuando el Optional no contiene ninguno.
Lo verás mejor en este ejemplo que te dejo aquí:
Ejemplo básico
Optional<String> optionalName = Optional.ofNullable(null);
String name = optionalName.orElse("Nombre por defecto");
System.out.println(name); // Salida: Nombre por defecto
¿Lo notaste? Mira que, como el Optional está vacío (null), el método orElse() devuelve “Nombre por defecto”.
Ejemplo práctico en un proyecto real
Ahora quiero que imagines que tienes una lista de usuarios y necesitas mostrar un nombre predeterminado si un usuario no está presente:
Optional<String> optionalUser = findUserById(101);
String displayName = optionalUser.orElse("Usuario anónimo");
System.out.println(displayName);
// Simulación del método de búsqueda
public static Optional<String> findUserById(int id) {
Map<Integer, String> users = Map.of(1, "Juan", 2, "Ana");
return Optional.ofNullable(users.get(id));
}
Observa bien que, si el usuario no existe, se mostrará “Usuario anónimo”.
Consejos a la hora de usar Optional.orElse() en Java
Como quiero que aproveches al máximo Optional.orElse() en Java, voy a dejarte algunas recomendaciones que a mí me sirvieron bastante:
Usa orElse() para valores por defecto simples
En caso de que ya esté disponible el valor por defecto y no necesites cálculo adicional, lo mejor es que uses orElse() así:
Optional<Integer> optionalAge = Optional.empty();
int age = optionalAge.orElse(18); // Valor por defecto fijo
System.out.println(age); // Salida: 18
Usa orElseGet() para cálculos costosos
La cosa cambia cuando el valor por defecto implica lógica compleja, en este caso si te recomiendo orElseGet(). (Más abajo te explico la diferencia entre estos dos).
Optional<Double> optionalPrice = Optional.empty();
double price = optionalPrice.orElseGet(() -> calculatePrice());
System.out.println(price);
// Método de cálculo costoso
public static double calculatePrice() {
System.out.println("Calculando precio...");
return 99.99;
}
Evita sobrecargar orElse() con lógica compleja
No te aconsejo que pases métodos que ejecutan tareas adicionales dentro de orElse(); porque se reduce la legibilidad y eficiencia de tu código.
Diferencia entre orElse() y orElseGet()
Se parecen, pero no son iguales. La gran diferencia se da en cómo cada uno evalúa sus argumentos:
- orElse(): Siempre va a evaluar el argumento que se le proporcionó, incluso cuando el Optional tiene un valor.
- orElseGet(): Solo evalúa el argumento si el Optional está vacío.
No pases esto por alto, porque reamente hace la diferencia en términos de rendimiento si el argumento requiere un cálculo costoso.
Ejemplo de rendimiento
Optional<String> optionalValue = Optional.of("KeepCoding");
String result = optionalValue.orElse(getExpensiveValue());
System.out.println(result); // Salida: KeepCoding
// Método que simula un cálculo costoso
public static String getExpensiveValue() {
System.out.println("Calculando valor costoso...");
return "Valor costoso";
}
¿Pudiste verlo? Mira bien que, incluso cuando el Optional tiene un valor, el método getExpensiveValue() se ejecutará, eso puede afectar el rendimiento en escenarios complejos.
Por otro lado, usando orElseGet():
String result = optionalValue.orElseGet(() -> getExpensiveValue());
System.out.println(result); // Salida: KeepCoding
En este caso, el método getExpensiveValue() no se ejecutará, ya que el valor en el Optional sí está.
Espero haberte ayudado a entender que Optional.orElse() en Java es fundamental, sobre todo para manejar valores predeterminados de forma segura y legible. No olvides lo que lo diferencia del método orElseGet() para que no tengas problemas de rendimiento.
¿Ya te visualizaste trabajando con Java y creando aplicaciones complejas y potentes? Nosotros te ayudamos a cumplir ese maravilloso sueño con nuestro Bootcamp de Java Full Stack. Te aseguramos que aprenderás a usar Optional y otros conceptos avanzados para no volver a estancarte nunca más en tu código. ¡Apúntate ahora mismo y transforma tu futuro en el sector IT con KeepCoding!