Java Tip 31: lo nuevo de Java (21)

El JDK ha tenido varias cambios en los últimos años. Características nuevas se han sumando a las que apenas conocemos.

En está entrega conoceremos las características del JDK 21.

Comencemos con Java 21.

Tabla con las nuevas características del JDK 21

Característica	Descripción
Patrones de registro (Record patterns)	Permiten descomponer objetos de tipo record directamente en sentencias instanceof y switch, facilitando la escritura de código más conciso y seguro
Patrones de switch (Pattern matching for switch)	Permite usar patrones en sentencias switch, mejorando la legibilidad y seguridad del código al trabajar con múltiples tipos y condiciones
Scoped values	Proporciona una alternativa más segura y eficiente a las variables ThreadLocal, permitiendo el paso de datos inmutables a través de llamadas de métodos y hilos
Virtual Threads (Hilos virtuales)	Permiten crear millones de hilos ligeros, facilitando la programación concurrente y escalable sin la sobrecarga de los hilos tradicionales
String Templates	Introducen plantillas de cadena que permiten interpolación y formateo más seguro y legible de strings
Sequenced Collections	Nuevas interfaces para colecciones ordenadas (SequencedCollection, SequencedSet, SequencedMap), proporcionando métodos consistentes para acceder a elementos en ambos extremos
Depuración y diagnóstico mejorados	Mejoras en el monitoreo, diagnóstico y trazabilidad de aplicaciones Java, incluyendo nuevas opciones de JVM y herramientas de profiling
Mejoras en el lenguaje y la JVM	Mejoras en rendimiento y eficiencia. Nuevas APIs y métodos en clases estandard. Depreciación y eliminación de APIs obsoletas
Actualizaciones de seguridad	Refuerzos en la seguridad de la plataforma y nuevas opciones de configuración para entornos empresariales

Veamos unos ejemplos para comprender mejor estas características.

Nuevas características del JDK 21

Patrones de registro (Record patterns)

Ejemplo de clases tipo Record.

record Point(int x, int y) {}

static void print(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println("X: " + x + ", Y: " + y);
    }
}

Permiten descomponer objetos record directamente en patrones, facilitando el acceso a sus componentes.

Ventajas:

• Menos código boilerplate. 
• Más legible y declarativo.

Patrones de switch (Pattern matching for switch)

El switch ahora permite evaluar tipos y patrones complejos.

static String format(Object obj) {
    return switch (obj) {
        case Integer i -> "Entero: " + i;
        case String s -> "Texto: " + s;
        case Point(int x, int y) -> "Punto: " + x + "," + y;
        default -> "Desconocido";
    };
}

Ventajas:

• Reemplaza múltiples if-else. 
• Código más limpio y elegante.

Scoped values

Alternativa moderna a ThreadLocal para compartir datos de forma segura en hilos (especialmente virtuales).

static final ScopedValue<String> USER = ScopedValue.newInstance();

ScopedValue.where(USER, "Thomas Muller").run(() -> {
    System.out.println(USER.get());
});

Ventajas:

• Más seguro que ThreadLocal.
• Ideal para concurrencia estructurada.

Virtual Threads (Hilos virtuales)

Una de las mayores innovaciones (Proyecto Loom): permite crear millones de hilos ligeros.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> System.out.println("Hola desde hilo virtual"));
}

Ventajas:

• Alta escalabilidad. 
• Código sencillo (estilo síncrono). 
• Reduce complejidad vs programación reactiva.

String Templates

Permite construir strings de manera más segura y flexible que concatenación.

String name = "Thomas Muller";
String message = STR."Hola \{name}";

También admite validación y procesamiento:

String sql = SQL."SELECT * FROM users WHERE name = \{name}";

Ventajas:

• Evita errores de concatenación.
• Facilita SQL seguro, HTML, etc.

Sequenced Collections

Nueva interfaz para colecciones con orden definido.

Nuevas APIs:

• getFirst() 
• getLast() 
• addFirst() 
• addLast()

Ejemplo:

SequencedCollection<String> list = new ArrayList<>();
list.addFirst("A");
list.addLast("B");

Ventajas:

• APIs consistentes para listas, sets y maps.
• Menos dependencia de implementaciones específicas.

Depuración y diagnóstico mejorados

Incluye mejoras como:

• Mejor soporte para heap dumps.
• Mejores herramientas de profiling.
• JFR (Java Flight Recorder) más potente.
• Diagnóstico mejorado de fallos de threads.

Ventajas:

• Diagnóstico más rápido de problemas.
• Producción más estable.

Mejoras en el lenguaje y la JVM

Incluyen:

• Optimizaciones de rendimiento en JVM. 
• Mejor recolección de basura (GC). 
• Mejor manejo de memoria. 
• Soporte optimizado para contenedores.

Ventajas:

• Apps más rápidas.
• Menor consumo de recursos.

Actualizaciones de seguridad

• Nuevos algoritmos criptográficos.
• Mejor validación de certificados.
• Refuerzo en TLS y APIs de seguridad.

Ventajas:

• Aplicaciones más seguras.
• Cumplimiento de estándares modernos.

Enlaces:

https://medium.com/@qingedaig/jdk-21-features-49ba9740b80e
https://www.happycoders.eu/java/java-21-features/
https://ricardogeek.com/caracteristicas-de-java-21-una-guia-completa-con-ejemplos-de-codigo/