Java 12 Funktionen

Endlich ist JDK 12, das Teil des sechsmonatigen Veröffentlichungszyklus ist, hier. Es kommt nach der letzten Java LTS-Version 11. Wir hatten ausführlich über die Java 11-Funktionen diskutiert. Heute werden wir die Java 12-Funktionen besprechen und sehen, was es für Entwickler bereithält. Java 12 wurde am 19. März 2019 veröffentlicht. Es handelt sich um eine Non-LTS-Version. Daher wird sie keine langfristige Unterstützung haben.

Java 12-Funktionen

Einige der wichtigen Java 12-Funktionen sind;

1. JVM-Änderungen – JEP 189, JEP 346, JEP 344 und JEP 230.
2. Switch-Ausdrücke
3. File mismatch() Methode
4. Kompakte Zahlenformatierung
5. Teeing Collectors in der Stream-API
6. Neue Methoden für Java-Strings – indent(), transform(), describeConstable() und resolveConstantDesc().
7. JEP 334: JVM-Konstanten-API
8. JEP 305: Musterabgleich für instanceof
9. Raw String Literals wurden aus JDK 12 entfernt.

Werfen wir einen Blick auf all diese Java 12-Funktionen nacheinander.

JVM-Änderungen

1. JEP 189 – Shenandoah: Ein Garbage Collector mit geringer Pausenzeit (Experimentell)

RedHat initiierte den Shenandoah Garbage Collector, um die Pausenzeiten des Garbage Collectors zu reduzieren. Die Idee ist, den Garbage Collector parallel zu den laufenden Java-Threads auszuführen. Ziel ist es, konsistente und vorhersehbare kurze Pausen unabhängig von der Heap-Größe zu erreichen. Es spielt also keine Rolle, ob die Heap-Größe 15 MB oder 15 GB beträgt. Dies ist ein experimentelles Feature in Java 12.

2. JEP 346 – Prompte Rückgabe ungenutzten zugewiesenen Speichers durch G1

Ab Java 12 überprüft G1 den Java-Heap-Speicher während der Inaktivität der Anwendung und gibt ihn an das Betriebssystem zurück. Dies ist eine vorbeugende Maßnahme, um freien Speicher zu erhalten und zu nutzen.

3. JEP 344: Abbruchfähige gemischte Sammlungen für G1

Verbesserungen in der G1-Effizienz umfassen das Abbrechen von gemischten G1-Sammlungen, wenn sie das definierte Pausenziel überschreiten könnten. Dies wird durch Aufteilen des gemischten Sammelsets in obligatorische und optionale Teile erreicht. So kann der G1-Sammler Priorität darauf legen, zuerst das obligatorische Set zu sammeln, um das Ziel der Pausenzeit zu erreichen.

4. JEP 230 und 344

Microbenchmark Suite, JEP 230 -Funktion fügt dem JDK-Quellcode eine grundlegende Suite von Mikrobenchmarks hinzu. Dies erleichtert es Entwicklern, vorhandene Mikrobenchmarks auszuführen und neue zu erstellen. Eine AArch64-Portierung, nicht zwei, JEP 344, entfernt alle Quellen, die mit dem arm64-Port zusammenhängen, während der 32-Bit-ARM-Port und der 64-Bit-aarch64-Port beibehalten werden. Dies ermöglicht es Beitragenden, ihre Bemühungen auf eine einzige 64-Bit-ARM-Implementierung zu konzentrieren.

5. JEP 341 Default CDS Archives

Dies verbessert den JDK-Buildprozess, um ein Klassen-Datenaustausch (CDS)-Archiv unter Verwendung der Standardklassenliste auf 64-Bit-Plattformen zu generieren. Das Ziel besteht darin, die Startzeit zu verbessern. Ab Java 12 ist CDS standardmäßig aktiviert. Um Ihr Programm ohne CDS auszuführen, führen Sie folgendes aus:

java -Xshare:off HelloWorld.java

Dies würde jedoch die Startzeit des Programms verzögern.

Sprachänderungen und Funktionen

Java 12 hat viele Sprachfunktionen eingeführt. Schauen wir uns einige mit Implementierungen an.

1. Schalterausdrücke (Vorschau)

Java 12 hat die Schalterausdrücke für Musterabgleich verbessert. Eingeführt in JEP 325, als eine Vorschau-Sprachfunktion, ist die neue Syntax L ->. Hier sind einige Dinge zu beachten über Schalterausdrücke:

• Die neue Syntax beseitigt die Notwendigkeit für eine break-Anweisung, um Fallstricke zu verhindern.
• Schalterausdrücke fallen nicht mehr durch.
• Zusätzlich können wir mehrere Konstanten im selben Label definieren.
• default-Fall ist jetzt obligatorisch in Schalterausdrücken.
• break wird in Schalterausdrücken verwendet, um Werte aus einem Fall selbst zurückzugeben.

Klassische Schalteranweisung:

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);

Mit dem neuen Schalterausdruck müssen wir nicht überall break setzen, um Logikfehler zu vermeiden!

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);

Führen wir das untenstehende Programm aus, das den neuen Schalterausdruck unter Verwendung von JDK 12 enthält.

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);
    }
}

Da dies eine Vorschau-Funktion ist, stellen Sie bitte sicher, dass Sie den Sprachlevel als Java 12 Vorschau ausgewählt haben. Um den obigen Code zu kompilieren, führen Sie den folgenden Befehl aus:

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

Nach Ausführung des kompilierten Programms erhalten wir folgende Ausgabe in der Konsole

. Schalterausdrücke sind eine Vorschausprachfunktion. Das bedeutet, dass sie zwar vollständig ist, aber möglicherweise nicht in zukünftigen Java-Versionen bestätigt wird.

2. Die Methode File.mismatch

Java 12 hat die folgende Methode hinzugefügt, um zwei Dateien zu vergleichen:

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

Diese Methode gibt die Position der ersten Abweichung zurück oder -1L, wenn keine Abweichung vorliegt. Zwei Dateien können in folgenden Szenarien unterschiedlich sein:

• Wenn die Bytes nicht identisch sind. In diesem Fall wird die Position des ersten nicht übereinstimmenden Bytes zurückgegeben.
• Die Dateigrößen sind nicht identisch. In diesem Fall wird die Größe der kleineren Datei zurückgegeben.

Ein Beispielcode-Schnipsel aus IntelliJ Idea wird unten gegeben:

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();



    }

}

Die Ausgabe, wenn das obige Java-Programm kompiliert und ausgeführt wird, ist:

3. Kompakte Zahlenformatierung

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. Sammelkollektoren

Der Teekollektor ist das neue Sammelwerkzeug, das in der Streams-API eingeführt wurde. Dieser Kollektor hat drei Argumente – zwei Sammler und eine Bifunktion. Alle Eingabewerte werden an jeden Sammler übergeben, und das Ergebnis steht in der Bifunktion zur Verfügung.

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

System.out.println(mean);

Die Ausgabe ist 3.0.

5. Neue Methoden für Java-Strings

In Java 12 wurden 4 neue Methoden eingeführt:

• einrücken(int n)
• transformieren(Funktion f)
• Optional describeConstable()
• String resolveConstantDesc​(MethodHandles.Lookup lookup)

Um mehr über die oben genannten Methoden und ihre Implementierung im Detail zu erfahren, siehe unser Tutorial zu Java 12 String Methods.

6. JEP 334: JVM-Konstanten-API

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: Mustererkennung für instanceof (Vorschau)

Ein weiteres Vorschau-Feature für die Sprache! Die alte Methode, einen Typ in einen anderen Typ zu konvertieren, lautet:

if (obj instanceof String) {
    String s = (String) obj;
    // ab hier s in deinem Code verwenden
}

Die neue Methode lautet:

if (obj instanceof String s) {
    // kann hier direkt s verwenden
} 

Dies erspart uns einige unnötige Typumwandlungen.

Raw String Literals werden aus JDK 12 entfernt.

Damit endet dieser Artikel über die Funktionen von Java 12.