De nieuwste revisie van Java introduceert onder andere enkele handige syntaxis voor records.

De wereld van Java-programmeren evolueert voortdurend, waardoor u up-to-date moet blijven om uit te blinken in uw vak.

Java 21 brengt een golf van opwindende verbeteringen die een revolutie teweegbrengen in de manier waarop u gelijktijdigheid, verzamelingsbewerkingen en het werken met records benadert.

Introductie van virtuele threads

Het schalen van serverapplicaties heeft altijd voor uitdagingen gezorgd, waarbij threads vaak knelpunten werden. Het beperkte aantal threads, in combinatie met het veelvuldig wachten op gebeurtenissen of vergrendelingen om de blokkering op te heffen, belemmert de algehele prestaties.

In het verleden betrof het aanpakken van dit probleem het gebruik van constructies zoals VoltooibareToekomst of reactieve kaders, resulterend in ingewikkelde code die moeilijk te begrijpen en te onderhouden was.

Gelukkig introduceerde Java 19 virtuele threads als een preview-functie, die Java 21 heeft verfijnd en verstevigd via JDK Enhancement Proposal 444.

Virtuele threads bieden een veelbelovend alternatief, waarmee u schaalbaarheidsuitdagingen effectiever kunt aanpakken. Dit leidt tot verbeterde prestaties en verbeterde responsiviteit van servertoepassingen.

Sequentiële collecties zijn beter bruikbaar

traditioneel, het gebruik van gekoppelde lijsten in uw Java-programmering heeft vrij uitgebreide code vereist. Om bijvoorbeeld het laatste element op te halen, moet u deze omslachtige aanpak gebruiken:

var laatste = lijst.get (lijst.grootte() - 1);

Java 21 introduceert echter een beknopt en elegant alternatief:

var laatste = lijst.getLast();

Evenzo vereist toegang tot het eerste element van een LinkedHashSet een rotonde:

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

Maar met Java 21 wordt deze taak veel eenvoudiger:

var eerste = linkedHashSet.getFirst();

U kunt ook toegang krijgen tot het laatste element van een LinkedHashSet met behulp van de nieuwe word laatste methode die iteratie door de hele set vermijdt.

Deze verbeteringen in reeksverzamelingen verbeteren niet alleen de leesbaarheid van de code, maar stroomlijnen ook het ophalen van elementen, waardoor Java-programmering efficiënter en ontwikkelaarsvriendelijker wordt.

Neem patronen op voor het gemak

Record Patterns, geïntroduceerd als een preview-functie in Java 19, bieden een handig mechanisme voor toegang tot de velden van een record in Java zonder de noodzaak van expliciete casts of toegangsmethoden.

Ze werken samen met Pattern Matching bijvoorbeeld van En Patroonaanpassing voor schakelaar, waardoor de code aanzienlijk wordt vereenvoudigd en de algehele leesbaarheid wordt verbeterd.

Hier is een illustratie van dit concept, met een eenvoudig record genaamd Positie:

openbaar dossier Positie(int X, int j){}

Voorheen was het uitvoeren van verschillende acties op basis van de klasse van een object vereist met behulp van Pattern Matching bijvoorbeeld van, zoals geïllustreerd in het volgende codefragment:

openbaarleegteafdrukken(Object){
als (O instantie van Positie p) {
 Systeem.out.printf("o is een positie: %d/%d%n", p.x(), p.y());
 } andersals (O instantie van Tekenreeks s) {
 Systeem.out.printf("o is een string: %s%n", S);
 } anders {
 Systeem.out.printf("o is iets anders: %s%n", o);
 }
}

Met Patronen opnemen, kunt u nu direct een opnamepatroon matchen, zoals Positie (int x, int y) in plaats van de Positie blz patroon. Hiermee krijgt u toegang tot de variabelen X En j rechtstreeks in de code, waardoor de noodzaak voor p.x() En p.j():

openbaarleegteafdrukken(Object){
als (O instantie vanPositie(int X, int j)) {
 Systeem.out.printf("o is een positie: %d/%d%n", x, y);
 } andersals (O instantie van Tekenreeks s) {
 Systeem.out.printf("o is een string: %s%n", S);
 } anders {
 Systeem.out.printf("o is iets anders: %s%n", o);
 }
}

Bovendien kunt u gebruiken Patronen opnemen in combinatie met Patroonaanpassing voor schakelaar, om uw code verder te vereenvoudigen:

openbaarleegteafdrukken(Object){
schakelaar (o) {
gevalPositie(int X, int j) -> Systeem.uit.printf("o is een positie: %d/%d%n", x, y);
geval Tekenreeks s - > Systeem.uit.printf("o is een string: %s%n", S);
standaard - > Systeem.uit.printf("o is iets anders: %s%n", o);
 }
}

Geneste opnamepatronen kunt u matchen op records waarvan de velden zelf records zijn. Neem bijvoorbeeld een record met de naam Pad dat omvat een van En naar positie:

openbaar dossier Pad(Positie van, Positie naar){}

Door opnamepatronen te gebruiken, kan het afdrukken van a Pad object wordt beknopter:

openbaarleegteafdrukken(Object){
schakelaar (o) {
gevalPad(Positie van, Positie naar) -> Systeem.uit.printf("o is een pad: %d/%d -> %d/%d%n", van.x(), van.j(), naar.X(), naar.j());
// andere gevallen
 }
}

Met behulp van Patronen opnemen, wordt het omgaan met records met velden van verschillende typen duidelijker en leesbaarder. Stel dat u gewijzigde records heeft, Positie2D En Positie3D, waar Positieis een Java-interface die beide implementeren:

openbaar verzegeld koppelPositievergunningenPositie2D, Positie3D{}
openbaar dossier Positie2D(int X, int j) implementeert positie {}
openbaar dossier Positie3D(int X, int j, int z) implementeert positie {}
openbaar opnemen Pad < P verlengt Positie > (P van, P naar) {}

Om het afdrukgedrag voor 2D- en 3D-paden te onderscheiden, kunt u recordpatronen gebruiken:

openbaarleegteafdrukken(Object){
schakelaar (o) {
gevalPad(Positie2D van, Positie2D naar) -> Systeem.uit.printf("o is een 2D-pad: %d/%d -> %d/%d%n", van.x(), van.j(), naar.X(), naar.j());
gevalPad(Positie3D van, Positie3D naar) -> Systeem.uit.printf("o is een 3D-pad: %d/%d/%d -> %d/%d/%d%n", van.x(), van.j(), van.z(), naar.X(), naar.j(), naar.z());
// andere gevallen 
 }
}

Recordpatronen verminderen de breedsprakigheid aanzienlijk en verbeteren de leesbaarheid van de code bij het omgaan met records die velden van verschillende typen bevatten.

Ontgrendel nieuwe mogelijkheden met Java 21

Java 21 introduceert een groot aantal krachtige functies die de mogelijkheden van de programmeertaal Java vergroten. Door deze verbeteringen te omarmen, kunt u uw ontwikkelingsprocessen stroomlijnen en nieuwe mogelijkheden voor uw toepassingen ontsluiten.

Door up-to-date te blijven met de nieuwste taalfuncties en Java-frameworks, kunt u efficiënte en onderhoudbare code onderhouden, zodat u in de voorhoede van Java-programmering blijft.