Nuevas características de Java 12

Oracle lanzó Java SE (Standard Edition) 12 el 19 de marzo de 2019, luego de lo cual planean tener un nuevo lanzamiento cada seis meses. JDK 12 vino con muchas mejoras sobre JDK 11 .

1. Cambios en las expresiones Switch :

Las expresiones Switch ahora se usarán como una declaración, así como también como expresiones. Esto hace posible la simplificación del código y la coincidencia de patrones para el conmutador.

• En versiones anteriores, la falta de sentencias de interrupción daba como resultado una caída predeterminada que era propensa a errores.
• El caso predeterminado es obligatorio en las expresiones de cambio.

Ahora, la nueva sintaxis de Flecha para cambiar se introdujo como  

case X -> {} 

Indica que solo si la etiqueta coincide, se ejecutarán las declaraciones en el lado derecho de la flecha.

Las expresiones Switch de Java 11 y Java 12 se pueden comparar de la siguiente manera:

Java 11

// Java program to demonstrate the
// classic switch statement
 
import java.io.*;
 
class Java11switchStatement {
 
    static int getMealNumber(String meal)
    {
        // stores mealNumber
        int mealNumber;
 
        // classic switch statement
        switch (meal) {
 
        case "SOUP":
            mealNumber = 1;
            break;
 
        case "BURGER":
 
        case "CHIPS":
 
        case "SANDWICH":
            mealNumber = 2;
            break;
 
        case "SPAGHETTI":
 
        case "MACARONI":
            mealNumber = 3;
            break;
 
        default:
            throw new IllegalStateException(
                "Cannot prepare " + meal);
        }
 
        return mealNumber;
    }
    public static void main(String[] args)
    {
 
        // define meal
        String meal = "BURGER";
 
        // print mealNumber
        System.out.println("The mealNumber is : "
                           + getMealNumber(meal));
    }
}

The mealNumber is : 2

Java 12

// Java program to demonstrate the
// new switch expression
 
import java.io.*;
 
class Java11switchStatement {
 
      // returns mealNumber
    static int getMealNumber(String meal)
    {
 
        // stores mealNumber using
        // new switch expression
        int mealNumber = switch (meal)
        {
 
           case "SOUP" -> 1;
 
           case "BURGER", "CHIPS", "SANDWICH" -> 2;
 
           case "SPAGHETTI", "MACARONI" -> 3;
             
           default -> throw new IllegalException("");
        }
 
        return mealNumber;
    }
   
    public static void main(String[] args)
    {
 
        // define meal
        String meal = "BURGER";
 
        // print mealNumber
        System.out.println("The mealNumber is : "
                           + getMealNumber(meal));
    }
}

Producción

The mealNumber is : 2

2. Shenandoah (un recolector de basura nuevo y mejorado)

Esta es una característica experimental e introduce un nuevo algoritmo de recolección de basura (GC), Shenandoah. Ofrece un tiempo de pausa bajo mediante la ejecución simultánea del trabajo de evacuación con la ejecución de subprocesos de Java. Con esto, los tiempos de pausa son independientes del tamaño del montón. Por ejemplo, un montón de 5 MB tendrá el mismo tiempo de pausa que uno de 10 GB.

3. API de constantes de JVM : esta API ayuda a aquellos programas que manipulan clases y métodos. Estos programas necesitan modelar instrucciones de código de bytes y manejar constantes cargables. Las constantes del tipo String o Integer funcionan bien. Sin embargo, se vuelve complicado con el tipo Constant como Clase. La carga de clases puede fallar si Class es inaccesible o no existe. Con la nueva API implementada, las interfaces como ClassDesc, MethodTypeDesc, MethodHandleDesc y DynamicConstantDesc manejan valores constantes simbólicamente, eliminando así la complejidad. 

4. Recopilaciones mixtas abortables para G1 : el recolector de elementos no utilizados predeterminado, Garbage First (G1), utiliza un motor de análisis para determinar el conjunto de recopilación y, una vez que comienza la recopilación, todos los objetos en vivo deben recopilarse sin detenerse. Esto da como resultado que se exceda el tiempo de pausa objetivo. Para solucionar este problema, los conjuntos de recopilación G1 se pueden anular dividiendo el conjunto en partes opcionales y obligatorias. Al priorizar el conjunto obligatorio, el objetivo de tiempo de pausa se puede lograr con frecuencia.  

5. Archivos CDS predeterminados : se crea un archivo de intercambio de datos de clase (CDS) para hacer que el proceso de compilación de JDK sea más eficiente, mejorando así el tiempo de inicio listo para usar.

6. Conjunto de microbenchmarks : los desarrolladores pueden ejecutar benchmarks existentes o nuevos fácilmente con el conjunto de microbenchmarks agregado al código fuente de JDK.

7. Devuelva rápidamente la memoria confirmada no utilizada de G1 : con esta función mejorada, cuando G1 está inactivo, el recolector de elementos no utilizados devuelve automáticamente la memoria en montón no utilizada al sistema operativo. Esto se hace mediante comprobaciones simultáneas del montón de Java por parte de G1.

8) Método Files.mismatch() : este nuevo método compara dos archivos.  

Firma del método

public static long mismatch(Path path1, Path path2) throws IOException

Devuelve: -1L si no hay discrepancia sino Posición de la primera discrepancia .

Devuelve la posición del desajuste en cualquiera de los dos casos.

• Caso 1 : si el tamaño de los archivos no coincide. Aquí, se devuelve el tamaño del archivo más pequeño.
• Caso 2 : si los bytes no coinciden. Aquí, se devuelve el primer byte que no coincide.

Ejemplo:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
 
public class FilesCompareExample {
 
    public static void main(String[] args)
        throws IOException
    {
        Path path1 = Files.createTempFile("file1", ".txt");
        Path path2 = Files.createTempFile("file2", ".txt");
        Files.writeString(path1, "Geeks for geeks");
        Files.writeString(path2, "Geeks for geeks");
 
        long mismatch1 = Files.mismatch(path1, path2);
 
        System.out.println(
            "File Mismatch position or -1 is returned if there is no mismatch");
 
        System.out.println(
            "Mismatch position in file1 and file2 is : "
            + mismatch1);
 
        path1.toFile().deleteOnExit();
        path2.toFile().deleteOnExit();
 
        System.out.println();
 
        Path path3 = Files.createTempFile("file3", ".txt");
        Path path4 = Files.createTempFile("file4", ".txt");
        Files.writeString(path3, "Geeks for geeks");
        Files.writeString(path4, "Geeks for the geeks");
 
        long mismatch2 = Files.mismatch(path3, path4);
 
        System.out.println(
            "Mismatch position in file3 and file4 is : "
            + mismatch2);
 
        path3.toFile().deleteOnExit();
        path4.toFile().deleteOnExit();
    }
}

 
Producción

Mismatch position in file1 and file2 is : -1 
Mismatch position in file3 and file4 is : 10 

9) Formato de número compacto : es el formato que se aplica a los números de propósito general, por ejemplo, decimal, moneda, porcentaje para hacerlos compactos debido a limitaciones de espacio. En el siguiente ejemplo, 1000 se formateará como ‘1K’ en un estilo corto y ‘1 mil’ en un estilo largo.

import java.text.NumberFormat;
import java.util.Locale;
 
public class CompactFormatExample {
    public static void main(String[] args)
    {
        NumberFormat fmtLong
            = NumberFormat.getCompactNumberInstance(
                Locale.US, NumberFormat.Style.LONG);
 
        System.out.println(fmtLong.format(100));
        System.out.println(fmtLong.format(1000));
        System.out.println(fmtLong.format(10000));
 
        NumberFormat fmtShort
            = NumberFormat.getCompactNumberInstance(
                Locale.US, NumberFormat.Style.SHORT);
 
        System.out.println(fmtShort.format(100));
        System.out.println(fmtShort.format(1000));
        System.out.println(fmtShort.format(10000));
    }
}

Producción

100
1 thousand
10 thousand
100
1K
10K

10) Teeing Collectors en Stream API : Collectors.teeing() es la nueva función auxiliar que ayuda a realizar la función de dos pasos en un solo paso. Esto da como resultado un código menos detallado.

Firma del método

public static Collector teeing​ (Collector downstream1, Collector downstream2, BiFunction merger);

Aquí, estamos realizando dos operaciones de transmisión diferentes en dos recopiladores diferentes y el resultado se fusiona utilizando el BiFunction suministrado .

Ejemplo:

import java.io.*;
import java.util.*;
 
class TeeingCollectorsExample {
    public static void main(String[] args)
    {
        double mean
            = Stream.of(2, 3, 4, 5, 6)
                  .collect(Collectors.teeing(
                      summingDouble(i -> i), counting(),
                      (sum, n) -> sum / n));
 
        System.out.println(mean);
    }
}

Producción

4.0

11) Nuevos métodos de Java String : Java 12 introdujo los siguientes métodos nuevos en la clase String:

i) sangría (int n) : ajusta la sangría de cada línea de la string dada en función del argumento pasado.

Según el valor de n pasado, podemos tener los siguientes casos:

• Si n > 0 , se insertan espacios al principio de cada línea
• Si n < 0 , los espacios se eliminan al principio de cada línea
• Si n < 0 y n < espacios en blanco disponibles , se eliminan todos los espacios iniciales
• Si n = 0 , la línea permanece sin cambios

String str = "**********\n  Welcome\n  Good Morning\n**********";
System.out.println(str.indent(0));
System.out.println(str.indent(3));

Producción

**********
  Welcome
  Good Morning
**********
   **********
     Welcome
     Good Morning
   **********
**********
Welcome
Good Morning
********** 

ii) transform(Function<? super String,​? extends R> f) : Se usa para llamar a una función esperando un argumento de string y produciendo el resultado R. 

String s = "Java,Python,Angular";
List result = s.transform(s1 -> {return Arrays.asList(s1.split(","));});
System.out.println(result);

Producción

[Java, Python, Angular]

iii) Optional<String> describeConstable() : este método devolverá un objeto Optional que contiene un descriptor para la instancia de String.

String message = "Welcome!";
Optional<String> opOfMessage = message.describeConstable();
System.out.println(opOfMessage);

Producción

Optional[Welcome!]

iv) String resolveConstantDesc​(MethodHandles.Lookup lookup) : este método devolverá un objeto String que es el descriptor de la instancia de String que invoca.

String message = "Welcome!";
String constantDesc = message.resolveConstantDesc(MethodHandles.lookup());
System.out.println(constantDesc);

Producción

Welcome!

Aunque Java 12 aún no ha ganado popularidad en comparación con Java 8, la adición de nuevas características con más frecuencia hace que Java sea comparable con mejores características de otros lenguajes, manteniendo así su popularidad en el mercado.