Java 22: todas las novedades

El pasado día 19 de marzo, como estaba previsto, Oracle liberó la versión 22 de Java.

La versión anterior de Java, JDK 21 (LTS), se lanzó el 19 de septiembre de 2023 y trajo 15 características nuevas (muchas en preview, como ahora) que incluyen patrones de registro, subprocesos virtuales, plantillas de cadenas (fase de vista previa) y más.

En JDK 22 se han añadido tan solo 2 cosas pequeñas en versión definitiva, siendo todo lo demás características en preview. Tampoco es una versión con soporte a largo plazo (LTS). Las versiones no LTS de Java se pueden usar para aplicaciones que necesitan las últimas funciones y mejoras. Sin embargo, es importante tener en cuenta que estas versiones tienen un período de soporte más corto y pueden ser menos estables.

Las versiones LTS de Java, o Long-Term Support, son versiones que reciben soporte y actualizaciones por un período más largo que las versiones regulares. Esto significa que son más confiables y estables para aplicaciones de producción. Cada dos años se lanza una nueva versión LTS de Java. Las versiones actuales de Java con soporte LTS son:

• Java 17: Lanzada en septiembre de 2021, con soporte hasta septiembre de 2026.
• Java 21: Lanzada en septiembre de 2023, con soporte hasta septiembre de 2028.

Las novedades incluidas en esta nueva versión Java 22 son las siguientes:

Novedades del Proyecto Amber

El proyecto Amber se centra en pequeñas pero importantes mejoras en el JDK para hacer el proceso de desarrollo más agradable. Incluye cambios como la inferencia de tipos de variables locales y otras mejoras del lenguaje que se han ido incorporando desde Java 10. En esta ocasión Java 22 incluye:

• JEP 447: Enunciados antes de super (en preview): da a los desarrolladores la libertad de expresar el comportamiento de los constructores. Al permitir que las instrucciones que no hacen referencia a la instancia que se está creando aparezcan antes de una invocación explícita del constructor, esta característica permite una ubicación más natural de la lógica que debe tenerse en cuenta en los métodos estáticos auxiliares, los constructores intermedios auxiliares o los argumentos del constructor. También conserva la garantía existente de que los constructores se ejecutan en orden descendente durante la creación de instancias de clase, lo que ayuda a garantizar que el código de un constructor de subclase no pueda interferir con la creación de instancias de superclase. Además, esta característica no requiere ningún cambio en la máquina virtual Java (JVM) y se basa únicamente en la capacidad actual de la JVM para verificar y ejecutar el código que aparece antes de las invocaciones explícitas del constructor dentro de los constructores.

  Por ejemplo, esto puede valer para hacer una validación de los argumentos de un constructor de la superclase. A veces necesitamos validar un argumento que se pasa al constructor. Podemos validar el argumento después del hecho, pero eso significa que podríamos estar haciendo trabajo innecesario:

  public class PositiveBigInteger extends BigInteger {
  
      public PositiveBigInteger(long value) {
          super(value);    //Trabajo quizá innecesario ya que la validación va despues
          if (value <= 0)
              throw new IllegalArgumentException("non-positive value");
      }
  }
  

  Sería mejor declarar un constructor que valide el argumento antes de que invoque el constructor de la superclase. Hasta ahora solo lo podíamos hacer en línea, utilizando un método estático auxiliar:

  public class PositiveBigInteger extends BigInteger {
  
      public PositiveBigInteger(long value) {
          super(verifyPositive(value));
      }
  
      private static long verifyPositive(long value) {
          if (value <= 0)
              throw new IllegalArgumentException("non-positive value");
          return value;
      }
  }
  

  Pero, este código sería más legible si pudiéramos incluir la lógica de validación directamente en el constructor:

  public class PositiveBigInteger extends BigInteger {
  
      public PositiveBigInteger(long value) {
          if (value <= 0)
              throw new IllegalArgumentException("non-positive value");
          super(value);
      }
  }
  

  que es justo lo que nos permite hacer ahora esta nueva característica en preview.

• JEP 456: Variables y patrones sin nombre: ayuda a mejorar la productividad de los desarrolladores mediante la mejora del lenguaje Java con variables y patrones sin nombre, que se pueden utilizar cuando se requieren declaraciones de variables o patrones anidados, pero luego nunca se utilizan. Esto reduce las oportunidades de error, mejora la legibilidad de los patrones de registro y aumenta la capacidad de mantenimiento de todo el código. En el caso de las variables se trata del clásico _ para asignar valores devueltos por funciones que luego no se van a utilizar, y que tienen ya hace años otros lenguajes como C#.

• JEP 459: Plantillas de cadenas (segunda preview): simplifica el desarrollo de programas Java al facilitar la expresión de cadenas que incluyen valores calculados en tiempo de ejecución, al tiempo que mejora la seguridad de los programas que componen cadenas a partir de valores proporcionados por el usuario y los pasan a otros sistemas. Además, se mejora la legibilidad de las expresiones mezcladas con texto, y se pueden crear valores que no son de cadena calculados a partir de texto literal y expresiones incrustadas sin tener que transitar por una representación de cadena intermedia.

  Por ejemplo:

  tring name = "María";
  String info = STR."Mi nombre es \{name}";
  assert info.equals("Mi nombre es María");   // true
  

• JEP 463: Clases declaradas implícitamente y métodos principales de instancia (segunda preview): ayuda a acelerar el aprendizaje al ofrecer una vía de acceso fluida a la programación Java para permitir a los estudiantes escribir sus primeros programas sin necesidad de comprender las características del lenguaje diseñadas para programas grandes. Básicamente es que, si activas la característica, no es necesario declarar la clase actual para definir su método main(). En lugar de esto:

  class HelloWorld {
      void main() {
          System.out.println("Hello, World!");
      }
  }
  

  Puedes escribir solo esto:

  void main() {
      System.out.println("Hello, World!");
  }
  

  De modo que no tienes que hablar de entrada de clases y los educadores pueden introducir conceptos de manera gradual, ya que los estudiantes pueden escribir declaraciones simplificadas para programas de una sola clase y expandir sin problemas sus programas para usar funciones más avanzadas a medida que crecen sus conocimientos.

Novedades del proyecto Loom

El proyecto Loom, busca introducir en Java un modelo de concurrencia ligero y de alto rendimiento en Java. Propone hilos virtuales (aparecidos en versión definitiva en Java 21), también conocidos como ‘fibers’, que son más escalables y eficientes que los hilos tradicionales del sistema operativo. En esta versión 22 las novedades que introduce son:

• JEP 462: Concurrencia estructurada (segunda preview): ayuda a los desarrolladores a optimizar el control y la cancelación de errores y a mejorar la observabilidad mediante la introducción de una API para la simultaneidad estructurada.
• JEP 464: Valores de ámbito (segunda preview): ayuda a aumentar la facilidad de uso, la comprensibilidad, el rendimiento y la solidez de los proyectos de los desarrolladores al permitir el intercambio de datos inmutables dentro y entre subprocesos.

Novedades del proyecto Panama

El proyecto Panama, dentro de Java, tiene como objetivo facilitar la interacción entre Java y las APIs externas (no Java), como código nativo en C o C++. Proporciona una forma más segura y eficiente de invocar funciones nativas y acceder a memoria externa, superando las limitaciones de la Java Native Interface (JNI). En Java 22 se han presentado las siguientes novedades dentro de este ámbito:

• JEP 454: Función foránea y API de memoria: aumenta la facilidad de uso, la flexibilidad, la seguridad y el rendimiento para los desarrolladores mediante la introducción de una API para permitir que los programas Java interoperen con código y datos fuera del runtime de Java. Al invocar de manera eficiente funciones externas, como código fuera de la máquina virtual Java, y al acceder de forma segura a la memoria externa (es decir, la memoria no administrada por la JVM), la nueva API permite que los programas Java llamen a bibliotecas nativas y procesen datos nativos sin necesidad de la interfaz nativa de Java.
• JEP 460: API vectorial (fase de séptima Incubadora): permite a los desarrolladores lograr un rendimiento superior a los cálculos escalares convencionales mediante la introducción de una API para expresar cálculos vectoriales que se compilan de forma confiable en tiempo de ejecución para vectorizar instrucciones en arquitecturas de CPU compatibles.

Características nuevas en las bibliotecas principales y las herramientas de Java

• JEP 457: API de archivo de clase (versión preview): ayuda a los desarrolladores a mejorar la productividad al proporcionar una API estándar para analizar, generar y transformar archivos de clase Java.
• JEP 458: Ejecución de programas de código fuente con varios archivos: permite a los desarrolladores elegir si desean configurar una herramienta de compilación y cuándo, mejorando el iniciador de aplicaciones Java para que pueda ejecutar un programa suministrado como varios archivos de código fuente Java.
• JEP 461: Recolectores de streams (Stream Gatherers, en preview): ayuda a los desarrolladores a mejorar la productividad mediante la mejora de la API de Stream para admitir operaciones intermedias personalizadas, lo que permitirá que las canalizaciones de flujo transformen los datos de formas que no se pueden lograr fácilmente con las operaciones intermedias integradas existentes. Al hacer que las canalizaciones de flujo sean más flexibles y expresivas y permitir que las operaciones intermedias personalizadas manipulen flujos de tamaño infinito, esta característica permite a los desarrolladores ser más eficientes en la lectura, escritura y mantenimiento del código Java.

Actualizaciones de rendimiento

• JEP 423: Fijación de región para G1: ayuda a reducir la latencia al permitir que se produzca cierta recolección de elementos no utilizados durante algunas llamadas a bibliotecas nativas que, de otro modo, habrían necesitado pausar el recopilador de basura. Esto se logra mediante el seguimiento de los objetos que deben bloquearse durante estas llamadas a la biblioteca nativa y "anclando" solo las regiones que contienen estos objetos. Esto permite que la recolección de elementos no utilizados continúe normalmente en regiones no ancladas, incluso durante lo que de otro modo habría sido una llamada de biblioteca nativa de bloqueo.

Puedes obtener más detalles de todo esto en cada JEP enlazado o en el artículo técnico oficial del lanzamiento de Java 22.