fbpx

Java 13 újdonságai – szöveges blokk

A szöveges blokk és a switch kifejezések lesznek talán a programozók mindennapjait közvetlenül befolyásoló új nyelvi eszköz a jövőben. De mik is ezek pontosan és hogy lehet ezeket használni? Milyen más újításokat vezet be a Java 13? Olvasd el lentebb!

Tartalom

  1. Mikor lesz elérhető a Java 13?
  2. Szöveges blokk – Text blocks (preview)
    1. Miért jó a szöveges blokk?
    2. Hogy néz ki a szöveges blokk?
  3. Switch kifejezések – Switch expressions (preview)
  4. ZGC: Nem használt memória felszabadítása az operációs rendszer számára
  5. Régi Socket API újraimplementálása
  6. Dinamikus CDS archívumok
  7. Összefoglalás

Mikor lesz elérhető a Java 13?

A végleges verzió várhatóan 2019. szeptember 17-én fog megjelenni. Néhány új nyelvi elem csak kísérleti jelleggel kerül bele a Java-ba, ezeket ha ki szeretnéd próbálni, akkor egy külön kapcsolóval kell ellátni a javac és java parancsokat. Részletesebben lásd lentebb!

De nem kell eddig várnod, hogy kísérletezz ezekkel az új feature-ökkel, hisz a GA (general availability) előtt is letölthetők a tesztelhető verziók.

Szöveges blokkok – Text blocks (preview)

A Java 13-mal érkezik ez a új feature, de egyelőre csak preview formában, vagyis még csak kísérleti jelleggel. Ha ki szeretnéd próbálni, akkor a programod fordításakor és indításakor a JVM-nek át kell adni a

--enable-preview

kapcsolót. Ennek hiányában a fordító bután fog rád nézni a forráskódod láttán.

Ha nem parancssorból futtatod a programod, akkor a kedvenc IDE-d legújabb verziójában a beállításoknál kell ezt engedélyezned. Eclipse esetén Window -> Preferences -> Java -> Compiler -> Enable preview features

szöveges blokk használatához szükséges beállítás Eclipse-ben
Preview feature bekapcsolása Eclipse-ben

Már a Java 12-be is terveztek egy raw string nevű feature-t, ami végül nem került bele, a kiadás előtti utolsó pillanatban kiszedték belőle. Ezek a nyers string-ek is hasonló ötlet alapján születtek, de végül a Java fejlesztő mérnökei úgy gondolták, hogy egy másik megközelítés lenne a megfelelőbb hosszú távon. A raw string, ahogy a nevük is utal rá, nyers szöveges literálok lettek volna, vagyis a kezdő és bezáró idézőjelei között nem értelmezte volna a JVM a speciális karaktereket.

Újragondolták ezt a megközelítést és a raw stringek helyett a text blokkok bevezetése mellett döntöttek a fejlesztők.

Miért jó a szöveges blokk?

A probléma, amit a szöveges blokk hivatott megoldani onnan fakad, hogy Java forráskódban sokszor kell más programozási nyelvek kódjait összeállítanunk. Gondolok itt például az adatbázis kezelésnél használatos SQL-re, a webes alkalmazásoknál a front-endnek küldendő JSON fájlokra, de akár XML-eknél és HTML-eknél is gondokba ütközünk. A problémát az okozza, hogy más programozási nyelv is használ olyan írásjeleket, speciális karaktereket, amik a Java számára is jelentőséggel bírnak. Például az idézőjel (“) a Java-ban a String literálok elejét és végét jelzi. Ha a String literál tartalmaz egy idézőjelet valahol a tartalmán belül, akkor ezt escape-elni kell egy backslash (\) szimbólummal, vagyis \” -t kell írnunk a kódunkba. Amikor HTML kódot Java-ban String-ként kezelünk, akkor olyan gyakran kell élnünk ezzel az escape-eléssel, hogy teljesen olvashatatlanná teszi a kódot. Gondot okoznak az új sor karakterek is, mert a Java-ban egy sima String literált egy sorban kell definiálni. Az új sor karaktert speciális \n escape szekvenciával kell jelölnünk, hogy belekerüljön a String literálunkba.

Hogy néz ki a szöveges blokk?

3 idézőjellel kell kezdődnie a szöveges blokknak és ezzel is kell záródnia.

String text = """        
                Az erős fókuszálású szinkrotronokban
                       rengeteg mágnes található, hogy fókuszálják a részecskenyalábot
                              és meggörbítsék a pályáját.              
        """

Fontos, hogy egy előfeldolgozáson esik át az ilyen módon megadott String literál, az első karaktere ennek a String-nek a nagy A betű lesz a mondat elején, holott egy csomó szóköz (whitespace) karakter megelőzi azt. Ezek a kezdeti whitespace-ek eldobásra kerülnek, egyfajta automatikus trim-elés történik. Ugyanez a helyzet a String literál végén is, az ottani szóközök is levágásra kerülnek. A mondat végén a pont után lesz egy sortörés. Ha ezt nem szeretnénk, akkor így kell megadnunk az előző szöveg blokkot:

String text = """        
                Az erős fókuszálású szinkrotronokban
                       rengeteg mágnes található, hogy fókuszálják a részecskenyalábot
                              és meggörbítsék a pályáját."""

Switch kifejezések – Switch expressions (preview)

A switch kifejezések már a Java 12-ben is kipróbálhatók voltak, erről írtam is egy blog posztot annak idején, aminek az átolvasását jó szívvel ajánlom továbbra is, hisz ez az egyik legnagyobb változás a Java nyelv eszközkészletét tekintve mostanság és a közeljövőben, ami a mindennapi programozás során előkerül és így használható. Az blog posztban leírtakhoz képest egy apró változás történt pusztán azóta. Amikor expression-ként, vagyis kifejezésként használjuk a switch-et, akkor a Java 12-s preview-ban még a break utasítást használhattuk egy értékkel együtt, hogy az adott switch kifejezés az adott értékkel térjen vissza mint helyettesítési értékkel, azonban a Java készítői úgy gondolták, hogy jobb lenne egy másik kulcsszót használni. Így ebben az esetben a break helyett a yield szót tudjuk majd használni. Persze a Java 13-ban is csak preview jelleggel került be ez az új feature, ezért ez még tovább változhat a következő verziókban, amíg nem véglegesítik.

String nameOfDay = "szombat";
int dayOfWeek = switch (nameOfDay) {
    case "hétfő": 
        yield 1;
    case "kedd":
        yield 2;
    case "szerda":
        yield 3;
    case "csütörtök":
        yield 4;
    case "péntek":
        yield 5;
    case "szombat":
        yield 6;
    case "vasárnap":
        yield 7;
    default:
        System.out.println("Ismeretlen nap.");
        yield 0;
};
System.out.println("Ez a(z) " + dayOfWeek + ". napja a hétnek.");

A yield egy új kulcsszó lesz a Java 13-tól kezdve.

ZGC: Nem használt memória felszabadítása az operációs rendszer számára

A Java 11 egyik kísérleti jelleggel bevezetett új szemétgyűjtője volt a Z Garbage Collector, vagy röviden ZGC. A több terabájtos heap-ek esetén is nagyon rövid megállási időket ígér. Az egyik hátránya az volt, hogy ha egy program sok memóriát igényelt a futása során, akkor a megnövekedett heap használat még ha az idővel meg is szűnt, akkor se tudta visszaadni a most már újra felszabadult memóriaterületet az operációs rendszernek. A Java 13-ban ezt a funkciót implementálták a ZGC esetén is.

Java 9-től kezdve az alapértelmezett garbage collector továbbra is a G1GC, vagyis a Garbage First Garbage Collector.

Régi Socket API újraimplementálása

A hálózati kommunikációt lehetővé tevő java.net csomagban található Socket és ServerSocket osztályok implementációi még a JDK 1.0-ban történtek, vagyis 1996-ban. Ezek feje felett igencsak eljárt már az idő, és több problémát is okoznak. Az eredeti implementációk régi Java és C kód keveréke, amit nehéz karbantartani és nehéz bennük hibát keresni.

Angolul itt tudsz erről többet olvasni, ha kíváncsi vagy a részletekre: JEP 353

Dinamikus CDS archívumok

A CDS, vagyis a Class Data Sharing, egy olyan már most is létező lehetősége a JVM-nek, ami az indítási idejét tudja felgyorsítani a programunknak, illetve memóriahasználat szempontjából is hasznos tud lenni. Egy alkalmazás osztályait lehet archiválni annak leállásakor, és így a futása alatt a class loader-ek által szerzett információt össze lehet gyűjteni egy archívumba, aminek a segítségével a következő indítás teljesítménye javítható. A Java 13-as újítás e téren segít ezen információk kigyűjtésében és nem lesz többé szükséges próbafuttatások végzése, mint korábban.

Összefoglalás

A Java 13-mal ez az 5 új feature kerül bele a nyelvbe, de ebből 2 még csak kísérleti jellegű, preview feature. Ezeket csak akkor tudod kipróbálni, ha egy külön kapcsolóval bekapcsolod a javac és a java programoknál, vagy az IDE-dben. A switch kifejezés a Java 12 verziója óta keveset változott, de még mindig ez az egyik olyan új lehetőség, amit a legtöbbet tudjuk majd a napi programozási feladataink során használni. A másik nagy újítás a text block, vagyis a szöveges blokk, ami egy igen rég óta várt funkció. A többsoros és speciális karaktereket tartalmazó String literálok beágyazása a forráskódunkba olvasható módon fantasztikus újítás. Mindezeket kipróbálhatod a végleges verzió várható szeptemberi megjelenése előtt.

Ha tetszett, oszd meg!

Szólj hozzá!