Hola, en este artículo te voy a hablar sobre la nueva versión de Java SE 20, que se lanzó el pasado 21 de marzo de 2023. Java SE 20 es una versión de soporte regular, que recibirá actualizaciones hasta la próxima versión, que será Java SE 21 LTS (Long Term Support). Java SE 20 trae varias novedades interesantes para los desarrolladores de Java, que te voy a explicar a continuación.

 

Una de las novedades más destacadas es el soporte preliminar para Scoped Values, que son valores inmutables que se pueden compartir entre hilos e intercambiar de forma eficiente entre hilos secundarios. Los Scoped Values se están desarrollando para reemplazar el mecanismo de variables locales de hilos, que son menos eficientes cuando se usa una gran cantidad de hilos virtuales. La principal diferencia entre Scoped Values y las variables locales de hilos es que los primeros se escriben una vez, no se pueden cambiar más tarde y permanecen disponibles solo durante la ejecución del hilo.

 

Otra novedad importante es la segunda implementación provisional de patrones de registro, que amplía la capacidad de coincidencia de patrones de Java 16 para analizar valores de clases de tipo registro. Las clases de registro son clases inmutables que contienen solo datos y se definen con una sintaxis compacta. Los patrones de registro permiten extraer los componentes de un valor de registro en una expresión switch o instanceof, sin necesidad de usar getters o constructores. Por ejemplo:

 

java
record Point(int x, int y) {}

Point p = new Point(3, 4);

// Usando patrones de registro
switch (p) {
case Point(x, y) - System.out.println("x = " + x + ", y = " + y);
default - System.out.println("No es un punto");
}

// Sin usar patrones de registro
switch (p) {
case Point point - System.out.println("x = " + point.x() + ", y = " + point.y());
default - System.out.println("No es un punto");
}
```

Una tercera novedad es la cuarta implementación provisional de la coincidencia de patrones en expresiones switch, que permite que las etiquetas case usen no valores exactos, sino plantillas flexibles que cubran una serie de valores a la vez. Esto evita tener que usar cadenas engorrosas de expresiones if-else para hacer coincidir varios casos. Por ejemplo:

```java
int n = 5;

// Usando coincidencia de patrones en switch
switch (n) {
case 0 - System.out.println("Cero");
case 1, 2 - System.out.println("Uno o dos");
case int i i 2 - System.out.println("Mayor que dos");
default - System.out.println("Otro valor");
}

// Sin usar coincidencia de patrones en switch
if (n == 0) {
System.out.println("Cero");
} else if (n == 1 || n == 2) {
System.out.println("Uno o dos");
} else if (n 2) {
System.out.println("Mayor que dos");
} else {
System.out.println("Otro valor");
}
```

Por último, otra novedad relevante es la segunda implementación preliminar de la API FFM (Foreign Function Memory), que permite organizar la interacción de programas Java con código y datos externos llamando a funciones desde bibliotecas externas y accediendo a la memoria fuera de la JVM. Esta API facilita la integración con código nativo sin necesidad de usar JNI (Java Native Interface) o JNA (Java Native Access), que son más complejos y menos seguros. Por ejemplo:

```java
// Llamando a una función externa desde Java
import jdk.incubator.foreign.*;

public class HelloFFI {
public static void main(String[] args) {
// Obteniendo el puntero a la función printf
LibraryLookup lookup = LibraryLookup.ofDefault();
MethodHandle printf = CLinker.getInstance().downcallHandle(
lookup.lookup("printf").get(),
MethodType.methodType(int.class, MemoryAddress.class),
Function