Características de Java 12

Finalmente, JDK 12, que forma parte del ciclo de lanzamiento de seis meses, está aquí. Viene después de la última versión LTS de Java 11. Ya hemos discutido extensamente sobre las características de Java 11 antes. Hoy estaremos discutiendo las características de Java 12 y viendo qué tiene reservado para los desarrolladores. Java 12 fue lanzado el 19 de marzo de 2019. Es una versión no LTS, por lo que no recibirá soporte a largo plazo.

Características de Java 12

Algunas de las características importantes de Java 12 son:

1. Cambios en la JVM – JEP 189, JEP 346, JEP 344 y JEP 230.
2. Expresiones Switch
3. Método mismatch() de archivos
4. Formato compacto de números
5. Teeing Collectors en Stream API
6. Nuevos métodos de cadenas Java – indent(), transform(), describeConstable() y resolveConstantDesc().
7. JEP 334: API de constantes de la JVM
8. JEP 305: Coincidencia de patrones para instanceof
9. Se ha eliminado el uso de literales de cadena sin formato en JDK 12.

Veamos todas estas características de Java 12 una por una.

Cambios en la JVM

1. JEP 189 – Shenandoah: Un Recolector de Basura de Bajo Tiempo de Pausa (Experimental)

RedHat inició el Recolector de Basura Shenandoah para reducir los tiempos de pausa de la recolección de basura. La idea es ejecutar la recolección de basura de manera concurrente con los hilos de Java en ejecución. Su objetivo es lograr pausas cortas consistentes y predecibles, independientemente del tamaño del montón (heap). Por lo tanto, no importa si el tamaño del montón es de 15 MB o 15 GB. Es una característica experimental en Java 12.

2. JEP 346 – Devolver Rápidamente la Memoria Comprometida No Utilizada de G1

A partir de Java 12, G1 verificará la memoria del montón de Java durante la inactividad de la aplicación y la devolverá al sistema operativo. Esta es una medida preventiva para conservar y utilizar la memoria libre.

3. JEP 344: Colecciones Mixtas Abortables para G1

Las mejoras en la eficiencia de G1 incluyen la posibilidad de abortar las recolecciones mixtas de G1 si podrían exceder el objetivo de pausa definido. Esto se logra dividiendo el conjunto de recolección mixta en obligatorio y opcional. De esta manera, el recolector G1 puede priorizar la recolección del conjunto obligatorio primero para cumplir con el objetivo de tiempo de pausa.

4. JEP 230 y 344

Suite de Microbenchmark, JEP 230 agrega una suite básica de microbenchmarks al código fuente de JDK. Esto facilita a los desarrolladores ejecutar microbenchmarks existentes y crear nuevos. Un puerto AArch64, no dos, JEP 344, elimina todas las fuentes relacionadas con el puerto arm64, manteniendo el puerto ARM de 32 bits y el puerto aarch64 de 64 bits. Esto permite que los colaboradores centren sus esfuerzos en una única implementación de ARM de 64 bits

5. JEP 341 Archivos CDS por Defecto

Esto mejora el proceso de compilación de JDK para generar un archivo de intercambio de datos de clases (CDS), utilizando la lista de clases predeterminada, en plataformas de 64 bits. El objetivo es mejorar el tiempo de inicio. A partir de Java 12, CDS está activado por defecto. Para ejecutar su programa con CDS desactivado, haga lo siguiente:

java -Xshare:off HelloWorld.java

Ahora, esto retrasaría el tiempo de inicio del programa.

Cambios en el Lenguaje y Funcionalidades

Java 12 ha introducido muchas características en el lenguaje. Veamos algunas con implementaciones.

1. Expresiones Switch (Vista previa)

Java 12 ha mejorado las expresiones Switch para el emparejamiento de patrones. Introducido en JEP 325, como una característica de lenguaje de vista previa, la nueva sintaxis es L ->. A continuación, algunas cosas a tener en cuenta sobre las expresiones Switch:

• La nueva sintaxis elimina la necesidad de la instrucción break para evitar caídas a través.
• Las expresiones Switch ya no caen a través.
• Además, podemos definir múltiples constantes en la misma etiqueta.
• El caso default es ahora obligatorio en las expresiones Switch.
• Se utiliza break en las expresiones Switch para devolver valores desde un caso en sí.

Declaración switch clásica:

String result = "";
        switch (day) {
            case "M":
            case "W":
            case "F": {
                result = "MWF";
                break;
            }
            case "T":
            case "TH":
            case "S": {
                result = "TTS";
                break;
            }
        };

        System.out.println("Old Switch Result:");
        System.out.println(result);

Con la nueva expresión Switch, no es necesario colocar break en todas partes, ¡evitando así errores lógicos!

String result = switch (day) {
            case "M", "W", "F" -> "MWF";
            case "T", "TH", "S" -> "TTS";
            default -> {
                if(day.isEmpty())
                    break "Please insert a valid day.";
                else
                    break "Looks like a Sunday.";
            }

        };

        System.out.println(result);

Veamos el siguiente programa que contiene la nueva expresión Switch utilizando JDK 12.

public class SwitchExpressions {

    public static void main(String[] args)
    {
        System.out.println("New Switch Expression result:");
        executeNewSwitchExpression("M");
        executeNewSwitchExpression("TH");
        executeNewSwitchExpression("");
        executeNewSwitchExpression("SUN");
    }

    public static void executeNewSwitchExpression(String day){

        String result = switch (day) {
            case "M", "W", "F" -> "MWF";
            case "T", "TH", "S" -> "TTS";
            default -> {
                if(day.isEmpty())
                    break "Please insert a valid day.";
                else
                    break "Looks like a Sunday.";
            }

        };

        System.out.println(result);
    }
}

Dado que esta es una función de vista previa, asegúrese de haber seleccionado el Nivel de Idioma como Java 12 vista previa. Para compilar el código anterior, ejecute el siguiente comando:

javac -Xlint:preview --enable-preview -source 12 src/main/java/SwitchExpressions.java

Después de ejecutar el programa compilado, obtenemos lo siguiente en la consola

Las expresiones de switch son una característica del lenguaje en vista previa. Esto significa que, aunque esté completa, puede que no esté confirmada en futuras versiones de Java.

2. Método File.mismatch

Java 12 agregó el siguiente método para comparar dos archivos:

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

Este método devuelve la posición de la primera discrepancia o -1L si no hay discrepancia. Dos archivos pueden tener una discrepancia en los siguientes escenarios:

• Si los bytes no son idénticos. En este caso, se devuelve la posición del primer byte que no coincide.
• Los tamaños de archivo no son idénticos. En este caso, se devuelve el tamaño del archivo más pequeño.

Ejemplo de fragmento de código de IntelliJ Idea se muestra a continuación:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class FileMismatchExample {

    public static void main(String[] args) throws IOException {
        Path filePath1 = Files.createTempFile("file1", ".txt");
        Path filePath2 = Files.createTempFile("file2", ".txt");
        Files.writeString(filePath1,"JournalDev Test String");
        Files.writeString(filePath2,"JournalDev Test String");

        long mismatch = Files.mismatch(filePath1, filePath2);

        System.out.println("File Mismatch position... It returns -1 if there is no mismatch");

        System.out.println("Mismatch position in file1 and file2 is >>>>");
        System.out.println(mismatch);

        filePath1.toFile().deleteOnExit();
        filePath2.toFile().deleteOnExit();

        System.out.println();

        Path filePath3 = Files.createTempFile("file3", ".txt");
        Path filePath4 = Files.createTempFile("file4", ".txt");
        Files.writeString(filePath3,"JournalDev Test String");
        Files.writeString(filePath4,"JournalDev.com Test String");

        long mismatch2 = Files.mismatch(filePath3, filePath4);

        System.out.println("Mismatch position in file3 and file4 is >>>>");
        System.out.println(mismatch2);

        filePath3.toFile().deleteOnExit();
        filePath4.toFile().deleteOnExit();



    }

}

La salida cuando se compila y ejecuta el programa Java anterior es:

3. Formato Compacto de Números

import java.text.NumberFormat;
import java.util.Locale;

public class CompactNumberFormatting {


    public static void main(String[] args)
    {
        System.out.println("Compact Formatting is:");
        NumberFormat upvotes = NumberFormat
                .getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.SHORT);
        upvotes.setMaximumFractionDigits(1);

        System.out.println(upvotes.format(2592) + " upvotes");


        NumberFormat upvotes2 = NumberFormat
                .getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.LONG);
        upvotes2.setMaximumFractionDigits(2);
        System.out.println(upvotes2.format(2011) + " upvotes");
    }


}

4. Colectores en T

El Colector en T es la nueva utilidad de recolección introducida en la API de Streams. Este colector tiene tres argumentos: dos colectores y una bi-función. Todos los valores de entrada se pasan a cada colector y el resultado está disponible en la bi-función.

double mean = Stream.of(1, 2, 3, 4, 5)
                .collect(Collectors.teeing(
                        summingDouble(i -> i),
                        counting(),
                        (sum, n) -> sum / n));

System.out.println(mean);

La salida es 3.0.

5. Nuevos Métodos de Cadenas en Java

Se han introducido 4 nuevos métodos en Java 12 que son:

• indent(int n)
• transform(Function f)
• Optional describeConstable()
• String resolveConstantDesc​(MethodHandles.Lookup lookup)

Para conocer más sobre los métodos anteriores y su implementación en detalle, consulte nuestro tutorial Métodos de Cadenas en Java 12.

6. JEP 334: API de Constantes de JVM

A new package java.lang.constant is introduced with this JEP. This is not that useful for those developers who don’t use constants pool.

7. JEP 305: Coincidencia de patrones para instanceof (Vista previa)

Otra característica de vista previa del lenguaje! La antigua forma de hacer un cast de un tipo a otro tipo es:

if (obj instanceof String) {
    String s = (String) obj;
    // usa s en tu código desde aquí
}

La nueva forma es:

if (obj instanceof String s) {
    // puedes usar s directamente aquí
} 

Esto nos ahorra algunos casting de tipo que eran innecesarios.

Los literales de cadena sin procesar se eliminan de JDK 12.

Esto pone fin a este artículo sobre las características de Java 12.