En este post vamos a ver un par de pequeñas novedades incluidas en Java en sus versiones 12 y 13 que nos permiten ser mas productivos en nuestro día a día trabajando con él.
Bloques de texto con triples comillas dobles
Hasta la versión 13 de Java, para definir una cadena de caracteres que tuviese varias lineas había que emplear concatenación de cadenas. Si esa cadena contenía el caracter comilla doble («) de inicio de cadena había que escaparlo; si esa cadena contenía saltos de línea había que emplear el carácter de escape de salto de línea \n.
El resultado es una cadena con problemas de legibilidad por los caracteres de escape que incluye en el código fuente del lenguaje. Esto podría darse al definir una cadena de texto que tuviera elementos HTML, JSON, sentencias SQL o expresiones regulares.
Algo que utilizamos muy comúnmente con una sentencia SQL es crearla en un gestor de base de datos donde se pueda ejecutar (por ejemplo: SQL Developper, Dbeaver,…) y al momento -tras probar que funciona correctamente- pasarla al código. Hasta esta ahora tenemos que estar concatenando cada línea y quedaría de la siguiente manera:
String sql = "" +
"UPDATE FPDUAL.USUARIOS " +
"SET NOMBRE = :nombre, " +
"APELLIDOS = :apellidos, " +
"IDIOMA_ID = :idioma " +
"WHERE ID = :id";Esto conlleva a perder un tiempo para ir concatenando la sentencia SQL. Tiempo que puede aumentar bastante si la sentencia es larga.
La utilización de las triple comillas dobles es sencilla; solo tenemos que crear la variable y escribir las triple comillas doble iniciales, al hacerlo el IntelliJ lo autocompleta con las otras triple comillas dobles finales.
Sería así:
String sql = """
...
""";Ahora solo tendríamos de copiar toda la sentencia SQL y pegarla entre las triple comillas doble triple iniciales y las finales, se quedaría así:
String sql = """
UPDATE FPDUAL.USUARIOS
SET NOMBRE = :nombre,
APELLIDOS = :apellidos,
IDIOMA_ID = :idioma
WHERE ID = :id
""";La ventaja es clara dado que ahora ya no tenemos que estar concatenando y formateando cada línea.
Otra ventaja de la utilización de las triple comillas dobles es en el proceso inverso. Es decir, si por algún motivo está dando problemas la sentencia SQL, podemos copiar la consulta y llevarla al gestor de base de datos para poder ejecutarla y ver que puede estar pasando.
Para eso copiamos el código de la sentencia SQL:
String sql = "" +
"UPDATE FPDUAL.USUARIOS " +
"SET NOMBRE = :nombre, " +
"APELLIDOS = :apellidos, " +
"IDIOMA_ID = :idioma " +
"WHERE ID = :id";Lo pegamos en el aplicativo (Dbeaver por ejemplo):
"UPDATE FPDUAL.USUARIOS " +
"SET NOMBRE = :nombre, " +
"APELLIDOS = :apellidos, " +
"IDIOMA_ID = :idioma " +
"WHERE ID = :id";Y para que se pueda lanzar la sentencia SQL tenemos que estar quitando en cada línea las comillas dobre iniciales y de las comillas doble finales hasta el final de la línea y solo así nos permitiría ejecutar la sentencia SQL.
Utilizando las triple comillas doble solo teníamos que copiar la sentencia SQL que está entre las triple comillas doble iniciales y las finales:
String sql = """
UPDATE FPDUAL.USUARIOS
SET NOMBRE = :nombre,
APELLIDOS = :apellidos,
IDIOMA_ID = :idioma
WHERE ID = :id
""";La pegamos en el programa y ya la podemos ejecutar sin estar quitando cosas en cada línea:
UPDATE FPDUAL.USUARIOS
SET NOMBRE = :nombre,
APELLIDOS = :apellidos,
IDIOMA_ID = :idioma
WHERE ID = :id ;Expresiones switch mejoradas
En la versión 12 de Java se aportó una mejora importante a los Switch.
Se añadió la posibilidad de que los switch fueran expresiones que retornan un valor en vez de sentencias y se evita el uso de la palabra reservada break. Se añadió también la posibilidad de utilizar varios casos para cada rama.
Un ejemplo del uso de un switch con el break y sin agrupaciones:
switch(numero) {
case 0: {
System.out.println("Nuetro");
break;
}
case 1: {
System.out.println("Impar");
break;
}
case 2: {
System.out.println("Par");
break;
}
/*
* ..........
*/
case 9: {
System.out.println("Impar");
break;
}
case 10: {
System.out.println("Par");
break;
}
default: {
System.out.println("No cuenta");
}
}El mismo ejemplo de antes pero ahora con las mejoras se quedaría así:
switch(numero){
case 0 -> {
System.out.println("Neutro");
}
case 1, 3, 5, 7, 9 -> {
System.out.println("Impar");
}
case 2, 4, 6, 8, 10 -> {
System.out.println("Par");
}
default -> {
System.out.println("PorDefecto");
}
}Las mejoras son claras en el uso del switch, se evitan repeticiones y posibles errores.
En la versión 13 de Java se aportó más una mejora interesante a los switch: tenemos la posibilidad de que en vez de retornar únicamente el valor ahora se pueda crear bloques de sentencias para cada rama case y retornar el valor con la palabra reservada yield. En los bloques de sentencias puede haber algún cálculo más complejo que directamente retornar el valor deseado.
Un ejemplo de como quedaría el switch con esta mejora sería:
String salida = switch(numero){
case 0 -> {
String valor = calculoNeutro();
yield valor;
}
case 1, 3, 5, 7, 9 -> {
String valor = calculoImpar();
yield valor;
}
case 2, 4, 6, 8, 10 -> {
String valor = calculoPar();
yield valor;
}
default -> {
String valor = calculoPorDefecto();
yield valor;
}
};¿Ya conocías estas funcionalidades? ¿Las usabas en tu trabajo diario? Cuentanos… 😉
