La última revisión de Java presenta una sintaxis útil para registros, entre otras mejoras.

El mundo de la programación Java está en constante evolución, lo que requiere que te mantengas actualizado para sobresalir en tu oficio.

Java 21 trae una ola de mejoras emocionantes que revolucionan la forma en que aborda la simultaneidad, las operaciones de recopilación y el trabajo con registros.

Introducción a los subprocesos virtuales

El escalado de aplicaciones de servidor siempre ha presentado desafíos, y los subprocesos a menudo se convierten en cuellos de botella. El número limitado de subprocesos, combinado con la espera frecuente de eventos o bloqueos para desbloquear, dificulta el rendimiento general.

En el pasado, abordar este problema implicaba el uso de construcciones como CompletableFuturo o marcos reactivos, lo que resultaba en un código intrincado que era difícil de comprender y mantener.

Afortunadamente, Java 19 introdujo subprocesos virtuales como una función de vista previa, que Java 21 ha refinado y solidificado a través de la Propuesta de mejora 444 de JDK.

instagram viewer

Los subprocesos virtuales ofrecen una alternativa muy prometedora, que le permite abordar los desafíos de escalabilidad de manera más efectiva. Esto conduce a un mejor rendimiento y una mayor capacidad de respuesta de las aplicaciones del servidor.

Las colecciones secuenciadas son más utilizables

Tradicionalmente, usando listas enlazadas en su programación Java ha requerido un código bastante detallado. Por ejemplo, para obtener el último elemento, debe utilizar este enfoque engorroso:

variable último = lista.obtener (lista.tamaño() - 1);

Sin embargo, Java 21 presenta una alternativa concisa y elegante:

variable último = lista.obtenerÚltimo();

De manera similar, acceder al primer elemento de un LinkedHashSet requiere una ruta indirecta:

variable primero = conjuntoHashConjunto.iterador().siguiente();

Pero con Java 21, esta tarea se vuelve mucho más sencilla:

variable primero = conjuntoHashConjunto.getPrimero();

También puede acceder al último elemento de un LinkedHashSet usando el nuevo obtener ultimo método que evita iterar a través de todo el conjunto.

Estas mejoras en las colecciones secuenciadas no solo mejoran la legibilidad del código, sino que también agilizan la recuperación de elementos, lo que hace que la programación Java sea más eficiente y fácil de usar para los desarrolladores.

Grabar patrones para mayor comodidad

Los patrones de registro, introducidos como una característica de vista previa en Java 19, ofrecen un mecanismo conveniente para acceder a los campos de un registro en Java sin necesidad de métodos de acceso o conversiones explícitos.

Hacen sinergia con Coincidencia de patrones para instancia de y Coincidencia de patrones para el interruptor, simplificando significativamente el código y mejorando la legibilidad general.

Aquí hay una ilustración de este concepto, con un registro simple llamado Posición:

público registro Posición(En t X, En t y){}

Previamente, realizar diferentes acciones basadas en la clase de un objeto requería usar Coincidencia de patrones para instancia de, como se ejemplifica en el siguiente fragmento de código:

públicovacíoimprimir(Objeto o){
si (o en vez de Posición p) {
 Sistema.fuera.printf("o es una posición: %d/%d%n", p.x(), p.y());
 } demássi (o en vez de Cadena s) {
 Sistema.fuera.printf("o es una cadena: %s%n", s);
 } demás {
 Sistema.fuera.printf("o es otra cosa: %s%n",o);
 }
}

Con Patrones de registro, ahora puede hacer coincidir directamente un patrón de registro como Posición (int x, int y) en lugar de usar el Posición p patrón. Esto le permite acceder a las variables. X y y directamente en el código, eliminando la necesidad de p.x() y p.y():

públicovacíoimprimir(Objeto o){
si (o en vez dePosición(En t X, En t y)) {
 Sistema.fuera.printf("o es una posición: %d/%d%n", x, y);
 } demássi (o en vez de Cadena s) {
 Sistema.fuera.printf("o es una cadena: %s%n", s);
 } demás {
 Sistema.fuera.printf("o es otra cosa: %s%n",o);
 }
}

Además, puedes usar Patrones de registro junto con Coincidencia de patrones para el interruptor, para simplificar aún más su código:

públicovacíoimprimir(Objeto o){
cambiar (o) {
casoPosición(En t X, En t y) - > Sistema.fuera.imprimir("o es una posición: %d/%d%n", x, y);
caso Cadena s -> Sistema.out.printf("o es una cadena: %s%n", s);
por defecto - > Sistema.out.printf("o es otra cosa: %s%n",o);
 }
}

Patrones de registros anidados le permite hacer coincidir registros cuyos campos son registros en sí mismos. Por ejemplo, considere un registro llamado Camino que comprende un de y a posición:

público registro Camino(Posición desde, Posición hasta){}

Al emplear patrones de registro, imprimir un Camino objeto se vuelve más conciso:

públicovacíoimprimir(Objeto o){
cambiar (o) {
casoCamino(Posición desde, Posición hasta) - > Sistema.fuera.imprimir("o es una ruta: %d/%d -> %d/%d%n", desde.x(), de.y(), a.X(), a.y());
// otros casos
 }
}

Con la ayuda de Patrones de registro, el manejo de registros con campos de diferentes tipos se vuelve más evidente y legible. Supongamos que ha modificado registros, Posición2D y Posición3D, dónde Posiciónes una interfaz Java que ambos implementan:

público sellado interfazPosiciónpermisosPosición2D, Posición3D{}
público registro Posición2D(En t X, En t y) Implementa Posición {}
público registro Posición3D(En t X, En t y, En t z) Implementa Posición {}
público registro Camino < P extiende Posición > (P desde, P a) {}

Para diferenciar el comportamiento de impresión de rutas 2D y 3D, puede utilizar patrones de registro:

públicovacíoimprimir(Objeto o){
cambiar (o) {
casoCamino(Posición2D desde, Posición2D hasta) - > Sistema.fuera.imprimir("o es una ruta 2D: %d/%d -> %d/%d%n", desde.x(), de.y(), a.X(), a.y());
casoCamino(Posición3D desde, Posición3D hacia) - > Sistema.fuera.imprimir("o es un camino 3D: %d/%d/%d -> %d/%d/%d%n", desde.x(), de.y(), de.z(), a.X(), a.y(), a.z());
// otros casos 
 }
}

Los patrones de registro reducen significativamente la verbosidad y mejoran la legibilidad del código cuando se trata de registros que contienen campos de diversos tipos.

Desbloquee nuevas posibilidades con Java 21

Java 21 presenta una serie de potentes características que aumentan las capacidades del lenguaje de programación Java. Al adoptar estas mejoras, puede optimizar sus procesos de desarrollo y desbloquear nuevas posibilidades para sus aplicaciones.

Mantenerse actualizado con las últimas características del lenguaje y los marcos de trabajo de Java le permite mantener un código eficiente y mantenible, lo que garantiza que se mantenga a la vanguardia de la programación de Java.