Die neueste Version von Java führt neben anderen Verbesserungen einige nützliche Syntax für Datensätze ein.

Die Welt der Java-Programmierung entwickelt sich ständig weiter und erfordert, dass Sie auf dem neuesten Stand bleiben, um in Ihrem Handwerk Spitzenleistungen zu erbringen.

Java 21 bringt eine Reihe spannender Verbesserungen mit sich, die Ihre Herangehensweise an Parallelität, Erfassungsvorgänge und die Arbeit mit Datensätzen revolutionieren.

Einführung in virtuelle Threads

Die Skalierung von Serveranwendungen war schon immer eine Herausforderung, da Threads häufig zu Engpässen führten. Die begrenzte Anzahl von Threads in Kombination mit dem häufigen Warten auf Ereignisse oder das Entsperren von Sperren beeinträchtigt die Gesamtleistung.

In der Vergangenheit erforderte die Lösung dieses Problems die Verwendung von Konstrukten wie Abschließbare Zukunft oder Reaktive FrameworksDies führte zu einem komplizierten Code, der schwer zu verstehen und zu warten war.

Glücklicherweise führte Java 19 virtuelle Threads als Vorschaufunktion ein, die Java 21 über den JDK Enhancement Proposal 444 verfeinert und gefestigt hat.

Virtuelle Threads bieten eine vielversprechende Alternative, mit der Sie Skalierbarkeitsherausforderungen effektiver bewältigen können. Dies führt zu einer verbesserten Leistung und einer verbesserten Reaktionsfähigkeit von Serveranwendungen.

Sequenzierte Sammlungen sind benutzerfreundlicher

Traditionell, Verwendung verknüpfter Listen in Ihrer Java-Programmierung hat ziemlich ausführlichen Code erfordert. Um beispielsweise das letzte Element abzurufen, müssen Sie diesen umständlichen Ansatz verwenden:

var last = list.get (list.size() - 1);

Allerdings führt Java 21 eine prägnante und elegante Alternative ein:

var last = list.getLast();

Ebenso erfordert der Zugriff auf das erste Element eines LinkedHashSet einen Umweg:

var first = linkedHashSet.iterator().next();

Aber mit Java 21 wird diese Aufgabe viel einfacher:

var first = linkedHashSet.getFirst();

Sie können auch mit new auf das letzte Element eines LinkedHashSet zugreifen getLast Methode, die das Durchlaufen des gesamten Satzes vermeidet.

Diese Verbesserungen bei sequenzierten Sammlungen verbessern nicht nur die Lesbarkeit des Codes, sondern rationalisieren auch das Abrufen von Elementen, wodurch die Java-Programmierung effizienter und entwicklerfreundlicher wird.

Zeichnen Sie Muster bequem auf

Datensatzmuster, die in Java 19 als Vorschaufunktion eingeführt wurden, bieten einen praktischen Mechanismus für den Zugriff auf die Felder eines Datensatzes in Java, ohne dass explizite Umwandlungen oder Zugriffsmethoden erforderlich sind.

Sie wirken synergetisch mit Mustervergleich für Instanz von Und Mustervergleich für Schalter, was den Code erheblich vereinfacht und die allgemeine Lesbarkeit verbessert.

Hier ist eine Veranschaulichung dieses Konzepts mit einem einfachen Datensatz mit dem Namen Position:

öffentlich aufzeichnen Position(int X, int y){}

Bisher war die Ausführung verschiedener Aktionen basierend auf der Klasse eines Objekts erforderlich Mustervergleich für Instanz von, wie im folgenden Codeausschnitt dargestellt:

öffentlichLeeredrucken(Objekt o){
Wenn (Ö Instanz von Position p) {
 System.out.printf(„o ist eine Position: %d/%d%n“, p.x(), p.y());
 } andersWenn (Ö Instanz von Zeichenfolge s) {
 System.out.printf(„o ist eine Zeichenfolge: %s%n“, S);
 } anders {
 System.out.printf(„o ist etwas anderes: %s%n“, Ö);
 }
}

Mit Muster aufzeichnen, können Sie jetzt ein Datensatzmuster direkt zuordnen, z Position (int x, int y) anstatt die zu verwenden Position S Muster. Dadurch haben Sie Zugriff auf die Variablen X Und j direkt im Code, wodurch die Notwendigkeit entfällt p.x() Und p.y():

öffentlichLeeredrucken(Objekt o){
Wenn (Ö Instanz vonPosition(int X, int y)) {
 System.out.printf(„o ist eine Position: %d/%d%n“, x, y);
 } andersWenn (Ö Instanz von Zeichenfolge s) {
 System.out.printf(„o ist eine Zeichenfolge: %s%n“, S);
 } anders {
 System.out.printf(„o ist etwas anderes: %s%n“, Ö);
 }
}

Darüber hinaus können Sie verwenden Muster aufzeichnen in Verbindung mit Mustervergleich für Schalter, um Ihren Code weiter zu vereinfachen:

öffentlichLeeredrucken(Objekt o){
schalten (Ö) {
FallPosition(int X, int y) -> System.out.printf(„o ist eine Position: %d/%d%n“, x, y);
Fall String s -> System.out.printf(„o ist eine Zeichenfolge: %s%n“, S);
Standard -> System.out.printf(„o ist etwas anderes: %s%n“, Ö);
 }
}

Verschachtelte Datensatzmuster ermöglichen es Ihnen, Datensätze abzugleichen, deren Felder selbst Datensätze sind. Betrachten Sie beispielsweise einen Datensatz mit dem Namen Weg das umfasst a aus Und Zu Position:

öffentlich aufzeichnen Weg(Position von, Position bis){}

Durch die Verwendung von Aufzeichnungsmustern wird das Drucken von a Weg Objekt wird prägnanter:

öffentlichLeeredrucken(Objekt o){
schalten (Ö) {
FallWeg(Position von, Position bis) -> System.out.printf(„o ist ein Pfad: %d/%d -> %d/%d%n“, from.x(), aus.j(), Zu.X(), Zu.j());
// andere Fälle
 }
}

Mit Hilfe von Muster aufzeichnen, wird der Umgang mit Datensätzen mit Feldern unterschiedlichen Typs klarer und lesbarer. Angenommen, Sie haben Datensätze geändert, Position2D Und Position3D, Wo Positionist eine Java-Schnittstelle dass beide implementieren:

öffentlich versiegelt SchnittstellePositionGenehmigungenPosition2D, Position3D{}
öffentlich aufzeichnen Position2D(int X, int y) implementiert Position {}
öffentlich aufzeichnen Position3D(int X, int ja, int z) implementiert Position {}
öffentlich Record Path < P erweitert Position > (P von, P nach) {}

Um das Druckverhalten für 2D- und 3D-Pfade zu unterscheiden, können Sie Datensatzmuster verwenden:

öffentlichLeeredrucken(Objekt o){
schalten (Ö) {
FallWeg(Position2D von, Position2D bis) -> System.out.printf(„o ist ein 2D-Pfad: %d/%d -> %d/%d%n“, from.x(), aus.j(), Zu.X(), Zu.j());
FallWeg(Position3D von, Position3D bis) -> System.out.printf(„o ist ein 3D-Pfad: %d/%d/%d -> %d/%d/%d%n“, from.x(), aus.j(), aus.z(), Zu.X(), Zu.j(), Zu.z());
// andere Fälle 
 }
}

Datensatzmuster reduzieren die Ausführlichkeit erheblich und verbessern die Lesbarkeit des Codes beim Umgang mit Datensätzen, die Felder verschiedener Typen enthalten.

Erschließen Sie neue Möglichkeiten mit Java 21

Java 21 führt eine Vielzahl leistungsstarker Funktionen ein, die die Fähigkeiten der Programmiersprache Java erweitern. Durch die Nutzung dieser Verbesserungen können Sie Ihre Entwicklungsprozesse optimieren und neue Möglichkeiten für Ihre Anwendungen erschließen.

Wenn Sie mit den neuesten Sprachfunktionen und Java-Frameworks auf dem Laufenden bleiben, können Sie effizienten und wartbaren Code pflegen und so an der Spitze der Java-Programmierung bleiben.