Java 21: Upptäck de senaste förbättringarna

Java-programmeringsvärlden utvecklas ständigt, vilket kräver att du håller dig uppdaterad för att utmärka dig i ditt hantverk.

Java 21 ger en våg av spännande förbättringar som revolutionerar hur du närmar dig samtidighet, insamlingsoperationer och arbete med poster.

Vi introducerar virtuella trådar

Skalning av serverapplikationer har alltid inneburit utmaningar, med trådar som ofta blivit flaskhalsar. Det begränsade antalet trådar, kombinerat med frekvent väntan på händelser eller låsningar för att låsa upp, hindrar övergripande prestanda.

Tidigare innebar att ta itu med denna fråga att använda konstruktioner som CompletableFuture eller reaktiva ramar, vilket resulterade i krystad kod som var svår att förstå och underhålla.

Lyckligtvis introducerade Java 19 virtuella trådar som en förhandsvisningsfunktion, som Java 21 har förfinat och solidifierat via JDK Enhancement Proposal 444.

Virtuella trådar erbjuder ett mycket lovande alternativ som låter dig tackla skalbarhetsutmaningar mer effektivt. Detta leder till förbättrad prestanda och förbättrad respons hos serverapplikationer.

Sekvenserade samlingar är mer användbara

Traditionellt, använda länkade listor i din Java-programmering har krävt ganska utförlig kod. Till exempel, för att hämta det sista elementet, måste du använda det här besvärliga tillvägagångssättet:

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

Java 21 introducerar dock ett kortfattat och elegant alternativ:

var last = list.getLast();

På samma sätt kräver åtkomst till det första elementet i ett LinkedHashSet en rondellväg:

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

Men med Java 21 blir den här uppgiften mycket enklare:

var first = linkedHashSet.getFirst();

Du kan också komma åt det sista elementet i ett LinkedHashSet med det nya getLast metod som undviker att iterera genom hela uppsättningen.

Dessa förbättringar i sekvenserade samlingar förbättrar inte bara kodläsbarheten utan effektiviserar också elementhämtningen, vilket gör Java-programmering mer effektiv och utvecklarvänlig.

Spela in mönster för bekvämlighet

Record Patterns, introducerad som en förhandsgranskningsfunktion i Java 19, erbjuder en bekväm mekanism för att komma åt fälten i en post i Java utan behov av explicita casts eller åtkomstmetoder.

De samverkar med Mönstermatchning till exempel och Mönstermatchning för switch, vilket avsevärt förenklar koden och förbättrar den övergripande läsbarheten.

Här är en illustration av detta koncept, med en enkel post som heter Placera:

offentlig spela in Placera(int x, int y){}

Tidigare krävde man att använda olika åtgärder baserat på ett objekts klass Mönstermatchning till exempel, som exemplifieras i följande kodavsnitt:

offentligtomhetskriva ut(Objekt o){
om (o instans av Position p) {
 System.out.printf("o är en position: %d/%d%n", p.x(), p.y());
 } annanom (o instans av Sträng s) {
 System.out.printf("o är en sträng: %s%n"s);
 } annan {
 System.out.printf("o är något annat: %s%n", o);
 }
}

Med Spela in mönster, kan du nu direkt matcha ett inspelningsmönster som t.ex Position (int x, int y) istället för att använda Position sid mönster. Detta låter dig komma åt variablerna x och y direkt i koden, vilket eliminerar behovet av p.x() och p.y():

offentligtomhetskriva ut(Objekt o){
om (o instans avPlacera(int x, int y)) {
 System.out.printf("o är en position: %d/%d%n"x, y);
 } annanom (o instans av Sträng s) {
 System.out.printf("o är en sträng: %s%n"s);
 } annan {
 System.out.printf("o är något annat: %s%n", o);
 }
}

Dessutom kan du använda Spela in mönster i samband med Mönstermatchning för switch, för att ytterligare förenkla din kod:

offentligtomhetskriva ut(Objekt o){
växla (o) {
fallPlacera(int x, int y) - > System.ut.printf("o är en position: %d/%d%n", x, y);
fall String s - > System.out.printf("o är en sträng: %s%n"s);
standard - > System.out.printf("o är något annat: %s%n", o);
 }
}

Kapslade skivmönster låter dig matcha på poster vars fält är själva poster. Tänk till exempel en post som heter Väg som omfattar en från och till placera:

offentlig spela in Väg(Position från, Position till){}

Genom att använda rekordmönster, trycka en Väg objektet blir mer kortfattat:

offentligtomhetskriva ut(Objekt o){
växla (o) {
fallVäg(Position från, Position till) - > System.ut.printf("o är en sökväg: %d/%d -> %d/%d%n", från.x(), från.y(), till.x(), till.y());
// andra fall
 }
}

Med hjälp av Spela in mönster, blir hanteringen av poster med fält av olika typer mer tydlig och läsbar. Anta att du har ändrat poster, Position 2D och Position 3D, var Placeraär ett Java-gränssnitt som båda implementerar:

offentlig sluten gränssnittPlaceratillståndPosition 2D, Position 3D{}
offentlig spela in Position 2D(int x, int y) implementerar Position {}
offentlig spela in Position 3D(int x, int y, int z) implementerar Position {}
offentlig spela in Sökväg < P utökar Position > (P från, P till) {}

För att skilja utskriftsbeteendet för 2D- och 3D-banor kan du använda inspelningsmönster:

offentligtomhetskriva ut(Objekt o){
växla (o) {
fallVäg(Position2D från, Position2D till) - > System.ut.printf("o är en 2D-sökväg: %d/%d -> %d/%d%n", från.x(), från.y(), till.x(), till.y());
fallVäg(Position3D från, Position3D till) - > System.ut.printf("o är en 3D-bana: %d/%d/%d -> %d/%d/%d%n", från.x(), från.y(), från.z(), till.x(), till.y(), till.z());
// andra fall 
 }
}

Postmönster minskar avsevärt information och förbättrar kodläsbarheten vid hantering av poster som innehåller fält av olika slag.

Lås upp nya möjligheter med Java 21

Java 21 introducerar en mängd kraftfulla funktioner som utökar funktionerna i programmeringsspråket Java. Genom att anamma dessa förbättringar kan du effektivisera dina utvecklingsprocesser och låsa upp nya möjligheter för dina applikationer.

Att hålla dig uppdaterad med de senaste språkfunktionerna och Java-ramverken ger dig möjlighet att upprätthålla effektiv och underhållbar kod, vilket säkerställer att du håller dig i spetsen för Java-programmering.