Java-Datensatzmuster wurden in Java 16 als Teil von Project Amber eingeführt und werden in Java 21 um Dekonstruktoren und Mustervergleich erweitert. Diese Funktion ermöglicht eine präzisere und flexiblere Art der Datenverarbeitung in Java-Anwendungen. In diesem Tutorial behandeln wir das Konzept von Datensatzmustern, wie sie beim Mustervergleich helfen, und verschiedene Codierungsbeispiele.
1. Kurze Zusammenfassung der Java-Datensätze
Bevor wir uns mit Datensatzmustern befassen, werfen wir einen kurzen Rückblick auf Java-Datensätze. Datensätze wurden in Java 14 als neuer Klassentyp eingeführt, der speziell für die Speicherung unveränderlicher Daten entwickelt wurde. Sie machen das Schreiben von Boilerplate-Code überflüssig, indem sie eine präzisere Syntax zum Definieren von Klassen mit Daten bereitstellen. Im folgenden Beispiel definieren wir einen Datensatz namens „Person“ mit drei Feldern: Vorname, Nachname und Alter.
record Person(String firstName, String lastName, int age) {}
Da Datensätze unveränderlich sind, schränken sie bestimmte Eigenschaften ein:
Datensätze generieren automatisch einen Konstruktor und Getter-Methoden für jedes Feld, wodurch sie besser für Datenträger geeignet sind als herkömmliche Klassen.
2. Was sind Aufnahmemuster?
Datensatzmuster, die in Java 21 eingeführt wurden, kombinieren das Konzept von Mustern mit Datensätzen, was eine einfache Dekonstruierung und Extraktion von Werten aus Datensätzen ermöglicht. Ein Datensatzmuster besteht aus einem Datensatzklassentyp und optionalen Mustervariablen, denen nur dann Werte zugewiesen werden, die aus dem Zieldatensatz extrahiert werden, wenn der Test erfolgreich ist.
Der Nullwert stimmt mit keinem Datensatzmuster überein, daher werden die Mustervariablen in diesem Fall nicht initialisiert.
3. Rekordzerstörer
Ein Destruktor ist die Umkehrung eines Konstruktors. Es extrahiert Werte aus einem Objekt, anstatt sie hinzuzufügen. Im Zusammenhang mit Datensätzen wird ein Destruktor als „Dekonstruktor“ bezeichnet. Es ermöglicht die Zerlegung von Datensatzwerten in ihre einzelnen Bestandteile. Angenommen, wir haben einen Datensatz namens „Name“ mit den folgenden Feldern:
Record Customer(String firstName, String lastName, int age) {}
Wir können einen Dekonstruktor verwenden, um die Werte dieser Felder aus einer Instanz des Datensatzes „Kunde“ zu extrahieren, wie im folgenden Beispiel gezeigt:
Kunde Kunde = neuer Kunde("Jane", "Smith", 30);
if (Customer-Instanz von Customer(String firstName, String lastName, int age)) {
System.out.println("Vorname: " + Vorname); // Jane
System.out.println("Nachname: " + Nachname); // Smith
System.out.println("Alter: " + Alter); // 30
}
Datensatzstrukturen können in Situationen nützlich sein, in denen wir mehrere verwandte Werte als ein einzelnes Objekt speichern und abrufen müssen. Die Dekonstruktionsfunktion von Datensätzen ermöglicht es uns, diese Werte einfach zu extrahieren und in unserem Code zu verwenden.
4. Muster in Switch-Anweisungen aufzeichnen
Mit Java 16 wurde der Mustervergleich für „instanceof“-Anweisungen eingeführt, der in Java 21 um „switch“-Anweisungen erweitert wurde. Es ermöglicht einen prägnanteren und lesbareren Code bei der Verarbeitung mehrerer Muster.
Angenommen, wir haben einen Datensatz namens „Konto“ mit drei Untertypen: „SavingAccount“, „CreditCardAccount“ und „HomeLoanAccount“. Jeder Untertyp hat eine andere Methode zur Berechnung seines Gleichgewichts. Wir können das Datensatzmuster in einer Switch-Anweisung verwenden, um diese drei Fälle zu behandeln, wie unten gezeigt:
Interface-Konto {}
Record SavingAccount (doppelter Saldo) implementiert Konto {}
Record CreditCardAccount(Double CreditLimit, Double Used) implementiert Konto {}
record HomeLoanAccount(double totalAmount, double amountPaid) implementiert Konto {}
Konto account= new CreditCardAccount(10000, 1000);
Schalter (Form) {
case SavingAccount s:
System.out.println("Kontostand ist " + Kontostand);
Pause;
case CreditCardAccount c:
System.out.println("Credit Balance is: " + (creditLimit-used));
Pause;
case HomeLoanAccount h:
System.out.println("Balence " +(totalAmount-amountPaid));
Pause;
Standard:
System.out.println("Unbekanntes Konto");
}
5. Verschachtelte Muster
Zusätzlich zum Extrahieren von Werten aus einem einzelnen Datensatz können Datensatzmuster auch verschachtelt werden, um komplexere Datensätze zu verarbeiten. Nehmen wir an, wir haben einen Datensatz mit dem Namen „Konto“, der ein Feld vom Typ „Kunde“ und ein weiteres Feld vom Typ „Adresse“ enthält. Wir können verschachtelte Datensatzmuster verwenden, um die Werte aus diesen beiden Feldern zu extrahieren, wie im folgenden Beispiel gezeigt:
Record Customer(String firstName, String lastName, int age) {}
Konto aufzeichnen (Kundenkunde, Adressadresse) {}
Kunde Kunde = neuer Kunde("John", "Doe", 25);
Adresse address = new Address("123 Main St.","City", "State");
Konto Konto = neues Konto (Kunde, Adresse);
if (Kontoinstanz von Konto(Kunde(fName, lName, Alter), Adresse(Straße, Stadt, Bundesland))) {
System.out.println("Vorname: " + fName); // John
System.out.println("Nachname: " + lName); // Doe
System.out.println("Alter: " + Alter); // 25
System.out.println("Adresse: " + Straße + ", " + Stadt + ", " + Bundesland); // 123 Main St., Stadt, Bundesstaat
}
In diesem Beispiel verwenden wir zwei verschachtelte Muster, um die Werte aus den Feldern „Kunde“ und „Adresse“ des Datensatzes „Konto“ zu extrahieren.
6. Komponentenzuordnung
Datensatzmuster bieten mehr Flexibilität, da Mustervariablen nicht mit den Komponentennamen eines Datensatzes übereinstimmen müssen. Solange sie kompatibel sind, ist der Mustervergleich erfolgreich. Zum Beispiel:
record Customer(String firstName, String lastName, int age) {}
Konto aufzeichnen (Kundenkunde, Adressadresse) {}
Kunde Kunde = neuer Kunde("John", "Doe", 25);
if (Customer-Instanz von Customer(var fn, var ln, var age)) {
System.out.println("Vorname: " + fn); // John
System.out.println("Nachname: " + ln); // Doe
System.out.println("Alter: " + Alter); // 25
}
// Auf verschachtelte Datensatzkomponenten zugreifen
Kontokonto = neues Konto(Kunde, neue Adresse("123 Main St", "New York", "NY"));
if (Account-Instanz von Account(var cust, var-Adresse)) {
System.out.println("Kunde: " + cust); // Kunde[Vorname=John, Nachname=Doe, Alter=25]
System.out.println("Adresse: " + Adresse); // Adresse[Straße=123 Main St, Stadt=New York, Bundesstaat=NY]
}
Hier unterscheiden sich die Mustervariablen „fn“ und „ln“ von den entsprechenden Komponentennamen „fName“ und „lName“ im Datensatz „Customer“. Dadurch werden Datensatzmuster flexibler und mögliche Konflikte mit Variablennamen werden vermieden.
7. Fazit
Zusammenfassend lässt sich sagen, dass Java-Datensatzmuster eine bequeme Möglichkeit bieten, Datensätze zu dekonstruieren und Werte daraus zu extrahieren. Sie machen den Code prägnanter, sauberer und lesbarer und handhaben gleichzeitig den Mustervergleich in Instanz- und Switch-Anweisungen. Datensatzmuster ermöglichen in Kombination mit Datensatzdestruktoren eine robustere Handhabung komplexer Datensätze. Insgesamt verbessert diese Funktion die Nutzung von Datensätzen als Datenträger und macht die Java-Programmierung angenehmer.
Entwickler können weitere Java 21-Funktionen entdecken, indem sie sich mithilfe der 1Z0-830-Übungstests von MyExamCloud auf die SE 21 Developer Certified Professional-Prüfung vorbereiten.
Das obige ist der detaillierte Inhalt vonErkunden von Java-Datensatzmustern und Mustervergleich. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
