10 mga tampok ng Java 8 na hindi mo pa naririnig.

Lambdas, lambdas, lambdas. Iyan lang ang maririnig mo kapag pinag-uusapan ng mga tao ang Java 8. Ngunit isang bahagi lang iyon. Maraming bagong feature ang Java 8 - ilang makapangyarihang bagong klase at idyoma, at ang iba ay mga bagay lang na dapat ay naroon na sa simula. Nais kong lumipat sa sampung bagong tampok na nakikita ko bilang maliliit na hiyas na talagang sulit na malaman. Siguradong may isa o dalawa sa kanila na gusto mong subukan, kaya magsimula na tayo! 1) Mga default na pamamaraan. Bago sa wikang Java, maaari ka na ngayong magdagdag ng mga katawan ng pamamaraan sa mga interface ( mga default na pamamaraan ). Ang mga pamamaraang ito ay walang kondisyong idinaragdag sa lahat ng klase na nagpapatupad ng mga interface na ito. Nagbibigay ito sa iyo ng pagkakataong magdagdag ng bagong functionality sa mga kasalukuyang library nang hindi sinisira ang lumang code. Siguradong dagdag iyon. Sa kabilang banda, seryoso nitong pinalabo ang linya sa pagitan ng interface, na nag-oobliga sa ilang kundisyon na dapat sundin bilang isang kombensiyon, at ang klase na sumusunod sa kanila, bilang pribadong pagpapatupad nito. Sa (kanang) kanang kamay, maaari itong maging isang eleganteng paraan upang gawing mas matalinong ang mga interface, maiwasan ang pag-uulit, at palawakin ang mga aklatan. Sa masamang kamay; makikita natin sa lalong madaling panahon ang mga pamamaraan sa mga interface na tinatawag ito at inihagis ito sa isang kongkretong uri. Brrr.... 2) Paghinto ng mga proseso. Ang pagsisimula ng karagdagang proseso ay isa sa mga bagay na ginagawa mo nang kalahating nalalaman na babalik ka (debug) upang i-debug ito kapag ang proseso (nag-crack) (nag-crash) ay nag-abort, (nag-hang) nag-hang, o gumagamit ng 100% ng CPU. Ang klase ng Proseso ay armado na ngayon ng dalawang bagong pamamaraan upang matulungan kang kontrolin ang mga hindi masusunod na proseso. Ang una, isAlive() , ay nagbibigay-daan sa iyong madaling suriin kung ang isang proseso ay tumatakbo nang hindi kinakailangang maghintay para dito. Ang pangalawa at mas makapangyarihan (babala!) ay destroyForcibly() , na nagbibigay-daan sa iyong (walang kahihiyan) na pilit na (patayin) ihinto ang isang proseso na lumampas sa oras nito (naghihintay o kung hindi man) o hindi na kailangan. 3) StampedLock. Ngayon para sa isang bagay na talagang kapana-panabik. Walang gustong mag-sync ng code. Ito ay isang tiyak na paraan upang pabagalin ang pagganap ng iyong application (lalo na sa isang malaking sukat) o mas masahol pa, maging sanhi ito upang mag-freeze. At gayon pa man, kung minsan ay wala kang pagpipilian. Maraming mga idiom para sa pag-synchronize ng multi-threaded na pag-access sa isang mapagkukunan. Isa sa mga pinakagusto ay ReadWriteLock at mga kaugnay na pagpapatupad. Binabawasan ng idyoma na ito ang pagtatalo sa pamamagitan ng pagpayag sa maraming thread na gumamit ng mapagkukunan habang hinaharangan lamang ang mga thread na nagmamanipula nito. Maganda ito, ngunit sa pagsasanay ay napakabagal ng lock na ito , lalo na sa maraming mga thread ng pagsusulat. Ito ay naging napakasama kaya ipinakilala ng Java 8 ang isang bagong RWLock na tinatawag na StampedLock . Ang lock na ito ay hindi lamang mas mabilis, ngunit nag-aalok din ng isang malakas na API para sa optimistic locking, kung saan makakakuha ka ng read lock sa murang halaga, umaasa na walang nakasulat na operasyon na magaganap sa mga kritikal na seksyon ng code. Sa dulo ng seksyon, tatanungin mo ang lock kung naganap ang pag-record sa panahong iyon, kung saan maaari kang magpasya kung susubukan muli, palakihin ang lock, o susuko. Ang lock na ito ay isang makapangyarihang tool at nararapat sa isang post tungkol sa sarili nito. Tuwang-tuwa ako sa bagong laruang ito. Malaki! Bilang karagdagan, maaari mong basahin Dito . 4) Mga nakikipagkumpitensyang recorder. Ito ay isa pang maliit na hiyas para sa sinumang nagpapatakbo ng mga multi-threaded na application. Isang simple at mahusay na bagong API para sa pagbabasa at pagsulat ng mga counter mula sa maraming thread. Minsan, mas mabilis pa ito kaysa sa paggamit ng AtomicIntegers. medyo kahanga-hanga! 5) Opsyonal (o opsyonal) na mga halaga. Oh, null pointers, sakit ng ulo para sa lahat ng developer ng Java. Marahil ang pinakasikat sa lahat ng mga pagbubukod, ito ay umiikot mula pa noong unang panahon. Hindi bababa sa mula noong 1965 . Ang paghiram mula sa Scala at Haskell, ang Java 8 ay may bagong pattern, na tinatawag na Opsyonal, para sa pagbabalot ng mga sanggunian na maaaring null. Ito ay hindi nangangahulugang isang pilak na bala na magwawakas ng null, ngunit isang paraan para sa mga taga-disenyo ng API upang ipahiwatig sa antas ng code (sa halip na dokumentasyon) na ang isang null na halaga ay maaaring ibalik o ipasa sa pamamaraan, at ang tumatawag ay dapat paghandaan ito. Kaya ito ay gagana lamang para sa mga bagong API, sa kondisyon na ang mga tumatawag ay hindi pinapayagan ang reference na makatakas mula sa wrapper, kung saan ito ay maaaring hindi ligtas na ma-dereference. Kailangan kong sabihin na medyo ambivalent ako tungkol sa feature na ito. Sa isang banda, ang nulls ay nananatiling isang malaking problema, kaya pinahahalagahan ko ang lahat ng nagawa upang malutas ito. Sa kabilang banda, medyo nag-aalinlangan ako na magtatagumpay ito. Ito ay dahil ang paggamit ng Opsyonal ay nangangailangan ng patuloy na pagsisikap mula sa buong kumpanya at may maliit na agarang epekto. Kung walang malakas na pagpapatupad, malamang na mananatili ito sa kaliwang bahagi ng kalsada. Magbasa pa tungkol sa Opsyonal . 6) I-annotate ang lahat. Isa pang maliit na pagsulong sa wikang Java: ang mga anotasyon ay maaaring idagdag sa halos lahat ng bagay sa iyong code. Dati, maidaragdag lang ang mga anotasyon sa mga bagay tulad ng mga klase o deklarasyon ng pamamaraan. Dahil ang Java 8, ang mga anotasyon ay maaaring idagdag sa mga deklarasyon ng variable at parameter, kapag nag-cast ng isang halaga sa isang partikular na uri, o kahit na naglalaan ng isang bagong bagay. Bahagi ito ng puro pagsisikap (kasama ang mga pagpapahusay sa mga tool at API ng JavaDoc) upang gawing mas friendly ang wika sa static na pagsusuri at mga tool sa pagsukat (tulad ng FindBugs). Ito ay isang magandang tampok, ngunit tulad ng invokeDynamic na ipinakilala sa Java 7, ang tunay na halaga nito ay depende sa kung ano ang ginagawa ng lipunan dito. 7) Mga pagpapatakbo ng overflow. Ngayon, narito ang isang hanay ng mga pamamaraan, na dapat ay bahagi ng pangunahing aklatan mula sa unang araw. Ang paborito kong libangan ay ang pag-debug ng mga numeric overflow kapag ang mga ints ay lumampas sa 2^32, at nagpapatuloy sa paglikha ng mga pinakamasama at hindi inaasahang mga error (ibig sabihin, "paano ako nakakakuha ng kakaibang halaga na ito?"). Muli, walang mga pilak na bala dito, ngunit maraming mga function para sa pagmamanipula ng mga numero na itinatapon kapag umapaw ang mga ito sa isang hindi gaanong mapagpatawad na paraan kaysa sa iyong karaniwang +/* operator, na walang kundisyon na umaapaw. 8) Maglakad sa katalogo. Ang pag-ulit sa mga nilalaman ng isang puno ng direktoryo ay matagal nang isa sa mga bagay na hinahanap ng mga tao sa Google (kung saan malamang na pinapayuhan kang gumamit ng Apache.FileUtils). Binibigyan ng Java 8 ang klase ng Files ng facelift na may sampung bagong pamamaraan. Ang paborito ko ay walk() , na lumilikha ng isang tamad na thread (mahalaga para sa malalaking file system) upang umulit sa mga nilalaman ng isang istraktura ng direktoryo. 9) Malakas na random na henerasyon. Walang kakapusan sa usapan ngayon tungkol sa kahinaan ng mga password at key. Ang seguridad ng software ay isang kumplikadong negosyo at madaling kapitan ng pagkakamali. Iyon ang dahilan kung bakit gusto ko ang bagong paraan ng SecureRandom. getinstanceStrong() , na awtomatikong pinipili ang pinakamalakas na random generator na magagamit para sa Java Virtual Machine. Binabawasan nito ang mga pagkakataong mabibigo ka o magkaroon ng mahinang generator, na gagawing mas madaling kapitan ng pag-hack ang mga susi at naka-encrypt na halaga. 10. Date.toInstant(). Ang Java 8 ay nagpapakilala ng ganap na bagong API para sa mga petsa at oras . Ito ay medyo naiintindihan dahil ang umiiral na isa ay hindi masyadong mahusay. Ang Joda ay mahalagang patungo sa isang Java API para sa mga petsa at oras sa loob ng ilang taon. Gayunpaman, kahit na sa bagong API, isang malaking problema ang nananatili - mayroong isang toneladang code at mga aklatan na gumagamit ng lumang API. At alam nating lahat na narito sila upang manatili. Ano ang gagawin mo? Upang makamit ito, ang Java 8 ay gumawa ng isang bagay na medyo elegante sa pamamagitan ng pagdaragdag ng isang bagong paraan sa klase ng Petsa na tinatawag na toInstant() na nagko-convert nito sa isang bagong API. Nagbibigay-daan ito sa iyong mabilis na tumalon sa bagong API, kahit na nagtatrabaho sa code na gumagamit ng lumang date API (at patuloy itong gagawin para sa nakikinita na hinaharap).