Mustervergleich und Aufzeichnung von Änderungen in Java, die jeder Java-Entwickler kennen muss

Mit der Veröffentlichung von Java 16 wurde mit der Einführung von Records (JEP 395) eine wesentliche Verbesserung eingeführt, die eine einfachere und prägnantere Möglichkeit zur Deklaration von Klassen ermöglichte, die hauptsächlich verwendet werden Daten zu transportieren. Diese Verbesserung wurde nun in Java 21 durch die Hinzufügung von Pattern Matching and Records (JEP 406) weiter verbessert. Diese neue Funktion ermöglicht die Verwendung von Mustervergleichen, um zu testen, ob ein Wert eine Instanz einer Record-Klasse ist, und um seine Komponenten auf effizientere Weise zu extrahieren. In diesem Artikel untersuchen wir die Änderungen, die Pattern Matching und Records in Java 21 mit sich bringen, und wie Java-Entwicklern davon zugute kommen können.

Aufzeichnungen als transparente Träger für Daten
Datensätze, die in Java 16 eingeführt wurden, sind Klassen, die hauptsächlich zum Speichern und Übertragen von Daten verwendet werden. Sie sind transparente Träger, was bedeutet, dass ihr Hauptzweck darin besteht, Daten zu speichern, und alle anderen Funktionen wie Konstruktoren, Methoden und Equals/HashCode-Methoden werden automatisch vom Compiler basierend auf den im Datensatz definierten Datenfeldern generiert. Dies macht sie ideal für den Einsatz in Szenarien, in denen Daten serialisiert oder über das Netzwerk gesendet werden müssen.

Betrachten Sie das Beispiel einer Line-Klasse, die zwei X- und Y-Koordinaten definiert:

Zeile aufzeichnen(int x, int y) {}

Um diese Klasse zu verwenden, können wir einfach eine Instanz der Line-Klasse erstellen und mit den integrierten Komponentenzugriffsmethoden x() und y() auf ihre Datenfelder zugreifen:

Zeile Zeile = neue Zeile(0, 10);
int x = line.x();
int y = line.y();
System.out.println("X: " + x + ", Y: " + y); // Ausgabe: X: 0, Y: 10

Mustervergleich mit Datensätzen
In Java 21 wurde Pattern Matching hinzugefügt, das es ermöglicht, zu testen, ob ein Wert eine Instanz einer Record-Klasse ist, und seine Komponenten auf effizientere Weise zu extrahieren. Diese Funktion ist besonders nützlich, wenn Sie mit großen Codebasen arbeiten, die Datensätze intensiv nutzen.

Betrachten Sie das folgende Beispiel, in dem wir testen möchten, ob ein Objekt eine Instanz der Line-Klasse ist, und seine Komponenten extrahieren möchten:

Statische Lückenlänge (Objektobjekt) {
if (obj-Instanz von Zeile l) {
int x = l.x();
int y = l.y();
System.out.println(y-x);
}
}
Wie Sie sehen können, haben wir ein Typmuster verwendet, um zu testen, ob das Objekt eine Instanz von Point ist, und wenn ja, haben wir seine Komponenten extrahiert, indem wir die integrierten Komponentenzugriffsmethoden aufgerufen haben. Obwohl dieser Code funktioniert, kann er durch die Verwendung eines Datensatzmusters in Java 21 weiter vereinfacht werden.

Mit dem Datensatzmuster können wir nicht nur testen, ob ein Wert eine Instanz einer Datensatzklasse ist, sondern wir können auch seine Komponenten in einer einzigen Codezeile extrahieren. Dies wird erreicht, indem die Deklaration lokaler Variablen für die extrahierten Komponenten in das Muster selbst verschoben wird und diese Variablen durch Aufrufen der Zugriffsmethoden initialisiert werden, wenn der Wert mit dem Muster abgeglichen wird.

Betrachten Sie den folgenden Code, der ein Datensatzmuster verwendet:

Statische Lückenlänge (Objektobjekt) {
if (obj Instanz von Line(int x, int y)) {
System.out.println(y-x);
}
}
Dieser Code ist viel prägnanter und lesbarer. Wir haben die Notwendigkeit beseitigt, ein neues Objekt zu erstellen und seine Komponentenzugriffsmethoden aufzurufen, um die Daten abzurufen. Das Datensatzmuster extrahiert und initialisiert die Komponenten direkt für uns, wodurch unser Code rationalisiert wird.

Verschachtelte Datensatzmuster
Eine der größten Herausforderungen für Entwickler ist der Umgang mit komplexen Objektgraphen und die Extraktion von Daten daraus. Hier kommt die wahre Stärke des Mustervergleichs ins Spiel, da er es uns ermöglicht, elegant zu skalieren und kompliziertere Objektdiagramme abzugleichen.

Berücksichtigen Sie die folgenden Klassen: Mitarbeiter, Abteilung (Aufzählung) und Unternehmen (Datensatz). Wir können ein Datensatzmuster verwenden, um die Abteilung eines Mitarbeiters aus einem Unternehmensobjekt zu extrahieren:

// Ab Java 21
static void printEmployeeDepartment(Company c, String name) {
if (c Instanz von Company(Department dept, List Mitarbeiter)) {
für (Mitarbeiter e: Mitarbeiter) {
if (e.getName().equals(name)) {
System.out.println(name + " ist in " + dept + " Abteilung.");
zurück;
}
}
}
System.out.println(name + „nicht gefunden.“);
}
In diesem Beispiel verwenden wir verschachtelte Muster, um die Abteilung eines Mitarbeiters aus einem Firmenobjekt zu extrahieren. Wir prüfen, ob das angegebene Firmenobjekt eine Abteilung und eine Liste von Mitarbeitern hat, und durchlaufen dann die Liste, um den Mitarbeiter mit dem angegebenen Namen zu finden. Wenn der Mitarbeiter gefunden wird, drucken wir seine Abteilung aus. Wenn nicht, drucken wir eine Nachricht aus, die besagt, dass der Mitarbeiter nicht gefunden wurde.

Verschachtelte Muster können auch in Situationen verwendet werden, in denen wir mehrere Werte gleichzeitig abgleichen und dekonstruieren möchten. Betrachten Sie das folgende Beispiel, in dem wir prüfen möchten, ob sich eine bestimmte Koordinate innerhalb eines Rechtecks ​​befindet:

//Ab Java 21
Record Point(double x, double y) {}

Rechteck aufzeichnen (Punkt oben links, Punkt unten rechts) {}

// Überprüfe, ob der angegebene Punkt innerhalb des angegebenen Rechtecks ​​liegt
statischer boolescher Wert isPointInsideRectangle(Punkt p, Rechteck r) {
if (r Instanz von Rechteck(Punkt(var x1, var y1), Punkt(var x2, var y2))) {
if (p.x() > x1 && p.y() > y1 && p.x() < x2 && p.y() < y2) {
return true;
}
}
return false;
}

In diesem Beispiel verwenden wir verschachtelte Muster, um zu überprüfen, ob ein bestimmtes Punktobjekt innerhalb der Grenzen eines bestimmten Rechteckobjekts liegt. Das verschachtelte Muster ermöglicht es uns, auf die x- und y-Koordinaten der oberen linken und unteren rechten Punkte des Rechtecks ​​zuzugreifen, ohne mehrere Codezeilen schreiben zu müssen.

Zusammenfassend lässt sich sagen, dass es mit der Hinzufügung von Pattern Matching and Records (JEP 406) in Java 21 eine deutliche Verbesserung in der Art und Weise gibt, wie wir Daten aus komplexen Objekten verarbeiten und extrahieren können. Diese Funktion vereinfacht den Code erheblich und macht ihn lesbarer und prägnanter. Es hilft auch bei der Handhabung von Fehlerszenarien, bei denen der Mustervergleich fehlschlagen könnte. Mit diesen Änderungen macht Java 21 den Code weiterhin schlanker und verbessert das Entwicklungserlebnis für Java-Entwickler.

Verbessern Sie Ihre Java 21-Kenntnisse mit den Java SE 21 Developer Professional Practice Tests von MyExamCloud. Entwickeln und testen Sie Ihr Wissen, um ein Java 21-Experte zu werden.

Das obige ist der detaillierte Inhalt vonMustervergleich und Aufzeichnung von Änderungen in Java, die jeder Java-Entwickler kennen muss. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!