Recenzia: Java 7 – Dolphine

Plat­for­ma Ja­va sa na kon­ci jú­la (pres­ne dvad­sia­te­ho ôs­me­ho) doč­ka­la po tak­mer pia­tich ro­koch svo­jej no­vej ma­jor ver­zie. Ver­zie Ja­vy od 5.0 (vrá­ta­ne) sa vždy vy­ví­ja­li pod kó­do­vým ozna­če­ním pod­ľa ne­ja­ké­ho zvie­ra­ťa a ani tá­to no­vá, vy­dá­va­ná pod (pre niek­to­rých šťas­tným) čís­lom 7, nie je vý­nim­kou – po Tig­ro­vi a Mus­tan­go­vi pri­chá­dza Dol­phi­ne (del­fín).

No­vá ma­jor ver­zia je vý­ni­moč­ná nie­len po­mer­ne dl­hým od­stu­pom od svo­jej pred­chod­ky­ne, ale i tým, že ide o pr­vú, kto­rá bo­la vy­da­ná už pod kríd­la­mi Orac­lu. V tom­to člán­ku sa oboz­ná­mi­me len s tým, aké zme­ny ja­zy­ka Ja­va pri­ná­ša (tzv. pod­pro­jekt Coin, vy­ví­ja­ný pod JSR-334). Ne­zao­be­rá­me sa os­tat­ný­mi zme­na­mi, kto­ré no­vá plat­for­ma pri­ná­ša (a kto­rých je ta­kis­to dosť).

Ope­rá­tor di­amant
Pr­vé zlep­še­nie ja­zy­ka Ja­va, kto­ré­ho sa vo ver­zii 7 doč­ká­me, je tzv. ope­rá­tor di­amant (di­amond), kto­rý po­zos­tá­va zo špi­ca­tých zá­tvo­riek - <>. Za je­ho za­ve­de­ním je sna­ha o od­strá­ne­nie nut­nos­ti ot­roc­ké­ho opa­ko­va­né­ho uvá­dzania ty­pov pri dek­la­rá­cii a in­štan­ciá­cii naj­mä zlo­ži­tej­ších ko­lek­cií. Ke­by sme dnes nap­rík­lad chce­li za­dek­la­ro­vať zoz­nam hash ta­bu­liek a zá­ro­veň ho in­štan­cio­vať, mu­se­li by sme pou­žiť nas­le­du­jú­ci zá­pis (ak ako im­ple­men­tu­jú­ci typ pre List pou­ži­je­me ArrayList):

 List<Map<In­te­ger, Ob­ject>> re­sult = new ArrayList<Map<In­te­ger,
Ob­ject>>();

 Z praxe is­te vie­te, že ty­py na ľa­vej i pra­vej stra­ne sa prak­tic­ky vždy bu­dú zho­do­vať, a pre­to sa to vždy kon­čí tri­viál­nym Ctrl + C a Ctrl + V. Spo­mí­na­ný no­vý ope­rá­tor nám umož­ňu­je kód zjed­no­du­šiť tak­to:

 List<Map<In­te­ger, Ob­ject>> re­sult = new ArrayList<>();

 Pri ta­kom­to zá­pi­se ope­rá­tor di­amant zna­me­ná jed­no­du­ché zde­de­nie dek­la­rá­cie ty­pu z ľa­vej stra­ny vý­ra­zu, čo zvý­ši preh­ľad­nosť kó­du a ube­rie troš­ku ot­rav­nej prá­ce prog­ra­má­to­ro­vi.

Re­ťaz­ce v blo­koch switch
Ďal­šie za­ují­ma­vé roz­ší­re­nie je mož­nosť pou­ži­tia re­ťaz­cov ako roz­ho­do­va­cích hod­nôt v blo­koch switch:

      String s = pic­kThe­Beat­le();
      switch (s) {
            ca­se "Paul": 
                  play­Bass();
            ca­se "John":
            ca­se "Geor­ge":
                  play­Gui­tar();
                  break;
            ca­se "Rin­go":
                  playD­rums();
                  break;
            de­fault:
                  play­Key­board();
                  break;
      }

 Ako vi­dí­me, re­ťaz­ce mož­no v blo­koch switch pou­ží­vať rov­na­kým spô­so­bom ako pri­mi­tív­ne dá­to­vé ty­py.

Preh­ľad­nej­šie čí­sel­né li­te­rá­ly
Me­dzi zme­ny, kto­rých prí­chod zrej­me ne­bu­de pat­riť me­dzi naj­oča­ká­va­nej­šie, by som za­ra­dil mož­nosť pou­ží­vať znak pod­čiar­kov­ník _ ( angl. un­der­sco­re) v čí­sel­ných li­te­rá­loch. To by ma­lo umož­niť preh­ľad­nej­ší (pre člo­ve­ka) zá­pis čí­sel v kó­de:

      int num­ber = 1_234_567;

Ne­chám na či­ta­te­ľo­vi, aby sám po­sú­dil, ako čas­to tú­to no­vú vlas­tnosť vy­uži­je. Na dopl­ne­nie do­dám, že ten­to znak sa dá pou­žiť v li­te­rá­loch rep­re­zen­tu­jú­cich ce­lé čís­la int a long, a to tak v de­siat­ko­vom zá­pi­se, ako i v os­tat­ných čí­sel­ných sús­ta­vách (vrá­ta­ne dvoj­ko­vej, kto­rá je za­ve­de­ná ako ďal­šia z no­vi­niek v Ja­ve 7, poz­ri ďa­lej).

Čí­sel­né li­te­rá­ly v dvoj­ko­vej sús­ta­ve
Ďal­šia zme­na, kto­rá sa zrej­me ta­kis­to za­ra­dí do ka­te­gó­rie me­nej vý­znam­ných. Po­kiaľ však niek­to čas­to pra­cu­je s čís­la­mi, kto­ré pot­re­bu­je za­pi­so­vať v dvoj­ko­vej sús­ta­ve a rep­re­zen­to­vať ich v prog­ra­me ako ce­lé čís­la, mô­že mu tá­to no­vá vlas­tnosť prísť vhod.

Ke­by sme v star­šej ver­zii Ja­vy chce­li za­pí­sať čís­lo v prog­ra­me v bi­nár­nej for­me a pri­tom ho rep­re­zen­to­vať ce­lo­čí­sel­nou pre­men­nou, mu­se­li by sme to uro­biť nas­le­du­jú­cim spô­so­bom:

       int bi­na­ry = In­te­ger.par­seInt("10110111", 2);

 Sa­moz­rej­me, ten­to spô­sob je ne­vý­hod­ný nie­len pre preh­ľad­nosť a dĺžku zá­pi­su, ale i pre vý­kon – me­tó­da par­seInt() je v tom­to prí­pa­de po­ma­lá a ta­kis­to je tu mož­nosť vy­ho­de­nia vý­nim­ky Num­ber­For­ma­tExcep­tion (i keď ne­kon­tro­lo­va­nej).

Ja­va 7 pre­to za­vá­dza mož­nosť jed­no­duch­šie­ho a vý­kon­nej­šie­ho zá­pi­su po­mo­cou pre­fixu 0b:

     int bi­na­ry = 0b10110111;
     int bi­na­ry = 0b1011_0111;  // mož­nosť
pou­ži­tia pod­čiar­kov­ní­ka

Auto­ma­tic­ká sprá­va zdro­jov
Pod tým­to náz­vom sa skrý­va no­vá vlas­tnosť zlep­šu­jú­ca klau­zu­lu try. Ide o po­mer­ne uži­toč­nú no­vin­ku naj­mä pri prá­ci s I/O API, te­da so vstup­ný­mi a vý­stup­ný­mi prúd­mi. Pri kla­sic­kom prís­tu­pe by sme nap­rík­lad pri čí­ta­ní úda­jov zo sú­bo­ru mu­se­li pos­tu­po­vať asi tak­to:

       Fi­leIn­putStream fis = null;
      try {
            fis = new Fi­leIn­putStream("vstup.txt");
            
            // ... na­čí­ta­va­me úda­je fis.read()
      } fi­nal­ly {
            if (fis != null) {
                  fis.clo­se();
            }
      }

 Ja­va 7 zjed­no­du­šu­je ten­to pos­tup tak­to:

       try (Fi­leIn­putStream fis = new Fi­leIn­putStream("vstup.txt")) {
            // ... na­čí­ta­va­me úda­je fis.read()
      }

Tak­to vy­tvo­re­ný zdroj bu­de auto­ma­tic­ky uzat­vo­re­ný (bu­de vo­la­ná je­ho me­tó­da clo­se()) po skon­če­ní blo­ku try. Aby bo­lo mož­né da­ný zdroj ta­kým­to spô­so­bom v blo­ku try pou­ží­vať, mu­sí da­ná trie­da im­ple­men­to­vať roz­hra­nie AutoC­lo­seab­le, kto­ré je ta­kis­to no­vin­kou v Ja­ve 7 a je v nej im­ple­men­to­va­né všet­ký­mi trie­da­mi rep­re­zen­tu­jú­ci­mi prú­dy v ja­vo­vej kniž­ni­ci I/O. Rov­na­ko mož­no pou­žiť ten­to zá­pis na ob­slu­hu via­ce­rých zdro­jov na­raz:

       try (
            Fi­leIn­putStream fis = new Fi­leIn­putStream("vstup.txt");
            Fi­leOut­putStream fos = new Fi­leOut­putStream("vy­stup.txt")
      ) {
            // ... na­čí­ta­va­me úda­je fis.read()
            // ... za­pi­su­je­me úda­je fos.wri­te()
      }

Je už na po­sú­de­ní prog­ra­má­to­ra, či bu­de tú­to zme­nu po­va­žo­vať za zlep­še­nie preh­ľad­nos­ti kó­du a vy­uži­je ju ale­bo zos­ta­ne pri sta­rom zá­pi­se, aby mo­hol mať lep­šiu kon­tro­lu nad tým, čo sa v prog­ra­me de­je.

Viac­ná­sob­ný blok catch
Ďal­šia no­vin­ka tý­ka­jú­ca sa blo­ku try-catch-fi­nal­ly je tzv. mul­ti-catch. Jej úlo­hou je zba­viť sa zby­toč­ne dup­li­ko­va­né­ho kó­du v tých klau­zu­lách catch, kto­rých ob­slu­ha vý­ni­miek je to­tož­ná:

       try {
            // kód po­ten­ciál­ne vy­ha­dzu­jú­ci vý­nim­ky
      } catch (IOExcep­tion e) {
            // ob­slu­ha chy­by, za­lo­go­va­nie atď.
      } catch (NullPoin­te­rExcep­tion e) {
            // ob­slu­ha chy­by, za­lo­go­va­nie atď.
      } catch (Num­ber­For­ma­tExcep­tion e) {
            // ob­slu­ha chy­by, za­lo­go­va­nie atď.
      }

 S po­dob­ným kó­dom sa už kaž­dý vý­vo­jár is­te stre­tol – opa­ko­va­ná ob­slu­ha vý­ni­miek nie­ke­dy za­bra­la i väč­ši­nu te­la me­tó­dy. Sčas­ti bo­lo mož­né ten­to prob­lém ob­čas vy­rie­šiť spo­loč­nou nad­trie­dou vý­ni­miek, ale to­to rie­še­nie bo­lo má­lo­ke­dy pou­ži­teľ­né. Ja­va 7 nám po­nú­ka jed­no­du­chý spô­sob, ako sa opa­ko­va­niu kó­du vy­hnúť:

 try {
      // kód
po­ten­ciál­ne vy­ha­dzu­jú­ci vý­nim­ky
} catch
(IOExcep­tion | NullPoin­te­rExcep­tion | Num­ber­For­ma­tExcep­tion e) {
      // ob­slu­ha
chy­by, za­lo­go­va­nie atď.
}

 Od­de­ľo­vač | (pi­pe) nám umož­ňu­je dek­la­ro­va­nie ľu­bo­voľ­né­ho poč­tu ty­pov vý­ni­miek. Prek­la­dač nám však ne­do­vo­lí uviesť dve vý­nim­ky, kde jed­na je pred­kom tej dru­hej – vte­dy tre­ba uviesť len nad­typ ale­bo vý­nim­ky od­chy­tiť via­ce­rý­mi blok­mi catch.

Pod­ľa môj­ho ná­zo­ru ide o po­mer­ne uži­toč­nú po­môc­ku.

Čo viac?
Zmien, kto­ré Ja­va 7 pri­ná­ša, je, sa­moz­rej­me, ove­ľa viac. Za zmien­ku sto­jí nap­rík­lad trie­da Ob­jects s uži­toč­ný­mi sta­tic­ký­mi me­tó­da­mi, no­vý Fork/Join fra­mework na pod­po­ru viac­vlák­no­vé­ho prís­tu­pu ale­bo pou­ži­tie kľú­čo­vé­ho slo­va fi­nal v klau­zu­le catch (tzv. ty­po­vo bez­peč­né opä­tov­né vy­vo­la­nie vý­nim­ky). Zlep­še­ný bol i ba­lí­ček I/O, kto­ré­mu pri­bud­la mož­nosť sle­do­vať zme­ny v sú­bo­ro­vom sys­té­me (WatchSer­vi­ce API) a rea­go­vať na ne, ale­bo gra­fic­ká kniž­ni­ca, kto­rá bo­la obo­ha­te­ná o no­vé efek­ty. Pre ma­lú časť vý­vo­já­rov mô­že byť za­ují­ma­vá zlep­še­ná pod­po­ra ty­po­vo dy­na­mic­kých ja­zy­kov.

Ďalej je ob­siah­nu­tých mno­ho ďal­ších drob­ných zlep­še­ní vý­ko­nu ale­bo ak­tua­li­zá­cií (JDBC, XML API im­ple­men­tá­cií, sie­ťo­vých pro­to­ko­lov, inter­na­cio­na­li­zá­cie atď.), kto­ré však vý­vo­jár bez kon­krét­nej úz­kej špe­cia­li­zá­cie asi väč­ši­nou ani ne­zaz­na­me­ná.

Ja­va 8
Ďal­šia ver­zia Ja­vy by ma­la byť vy­da­ná kon­com bu­dú­ce­ho ro­ka a ok­rem iné­ho by sa v nej ma­li ob­ja­viť i no­vin­ky, kto­ré do nej bo­li pre­su­nu­té z Ja­vy 7, ako sú nap­rík­lad pro­jekt Jig­saw na mo­du­la­ri­zá­ciu JDK ale­bo ak­tua­li­zá­cia Swing fra­mewor­ku (nap­rík­lad s no­vým gra­fic­kým pr­vkom na vý­ber dá­tu­mu). Veľ­mi za­ují­ma­vé sú zme­ny v ja­zy­ku, pre­to­že by sa ma­li za­viesť tzv. lam­bda vý­ra­zy (pro­jekt Lam­bda). A pre mňa naj­zau­jí­ma­vej­ší je pro­jekt na za­ve­de­nie pod­po­ry jed­no­duch­šej prá­ce s ko­lek­cia­mi, naj­mä pod­po­ra in­dexova­né­ho prís­tu­pu k nim. Tá­to vlas­tnosť nap­rík­lad umož­ní nás­led­ne pra­co­vať s ta­buľ­ka­mi ako s aso­cia­tív­ny­mi po­ľa­mi. Na to­to všet­ko si však bu­de­me mu­sieť eš­te chvíľ­ku poč­kať.

Zdroj: Infoware 8-9/2011

---

 

---