Nasanay na kami sa katotohanan na may lumalabas na bagong release ng JDK tuwing anim na buwan. Sa ngayon, ang diskarte na ito ay nabigyang-katwiran ang sarili nito, at ang mga alalahanin ng ilang mga developer na hindi sila makakasabay sa mga pag-update ay naging walang kabuluhan: may ilang anim na buwang pagbabago at hindi na sila global gaya ng dati. Buweno, maaaring hindi mapansin ng mga baguhang programmer ang pagbabago. Gayunpaman, mas mabuti para sa mga developer ng software sa hinaharap na manatiling abreast ng mga inobasyon. Sa artikulong ito, tradisyonal naming ilalarawan ang mga tinanggap na panukala sa pagpapalawig (JEPs). Ang Java 13 ay kinabibilangan lamang ng limang JEP at 76 na bagong pangunahing elemento ng library (na halos kalahati ay mga simpleng karagdagan sa java.io package).
Magsimula tayo sa pagbabago ng syntax ng wika. Ang pinakamahalaga sa kanila ay mga bloke ng teksto. Pinapayagan ka nitong maiwasan ang pagtakas ng mga character at malaman kung paano i-format ang mga string. Maaari mong tandaan na hindi kasama sa JDK 12 ang inaasahang tampok na Raw String Literals (JEP 326) para sa pagtatrabaho sa mga literal na string. Sa Java 13, pinalitan ito ng JEP 355 kasama ang mga text block nito. Marahil ay naaalala mo na sa Java, ang isang string ay nakabalot sa mga dobleng panipi. Maganda ito, ngunit ang problema ay hindi maaaring sakupin ng isang linya ang higit sa isang linya ng source file (upang maiwasan ang pagkalito sa isang linya ng Java, dito tatawagin natin ang isang linya ng file bilang "linya"). Buweno, maglibot tayo at gamitin, halimbawa, ang simbolo \nkung kinakailangan ng pahinga, o pagsasama-sama ng mga multiline na expression. Hindi maganda ang lalabas! Ang mga literal na teksto na may naka-embed na HTML, XML, SQL, o JSON na mga fragment ay lalong mahirap. Ang lahat ng escaping, concatenation, at manu-manong pag-edit na ito ay ginagawang hindi maginhawang isulat at mahirap basahin ang code. Sinusubukan ng mga bloke ng teksto na lutasin ang problemang ito. Nagsisimula sila uh... na may triple double quotes at nagtatapos sa kanila (alam ko, hindi ito masyadong maganda). Ang lahat sa pagitan ng mga quote ay binibigyang kahulugan bilang bahagi ng linya, kabilang ang mga bagong linya. Ang mga bloke ng teksto ay maaaring gamitin nang eksakto kapareho ng mga karaniwang literal na teksto, at ang Java ay bubuo ng code sa parehong paraan. Ang pagbubukas ng mga quote ay dapat na sinundan ng isang line delimiter; hindi magagamit ang mga text block sa isang linya, kaya ang code
String smallBlock ="""Only one line""";
hahantong sa mga sumusunod na pagkakamali:
TextBlock.java:3: error: illegal text block opendelimiter sequence, missing line terminator
String smallBlock ="""Text Block""";^TextBlock.java:3: error: illegal text block opendelimiter sequence, missing line terminator
String smallBlock ="""Text Block""";^
Ang isang simpleng HTML fragment ay maaari na ngayong isulat tulad nito:
Magbanggit tayo ng ilang mga subtleties na mas mahusay na malaman kapag gumagamit ng mga bloke ng teksto. Ang paglalagay ng mga pagsasara ng mga panipi ay lumalabas na mahalaga: tinutukoy nito kung paano pinangangasiwaan ang paminsan-minsang puting espasyo. Sa halimbawa sa itaas, ang mga pansarang panipi ay nakahanay sa indentasyon ng HTML na teksto. Sa kasong ito, aalisin ng compiler ang mga puwang ng indentation, at bilang resulta ay makakakuha tayo ng linyang tulad nito:
<html><body><p>My web page</p></body></html>
Tandaan:ang nasabing linya ay maglalaman ng bagong linya sa dulo ng linya. Kung hindi ito kailangan, ang pagsasara ng mga quote na """ ay maaaring ilagay nang direkta pagkatapos ng tag na </html>. Kung ililipat namin ang pagsasara ng mga panipi sa kaliwang margin, babaguhin nito ang dami ng indentation na inalis. Kung ililipat namin ang mga ito ng dalawang puwang sa kaliwa, magdaragdag kami ng dalawang puwang para sa indentation sa bawat linya ng linya. Ang paglipat sa kaliwang gilid ay magiging sanhi ng lahat ng padding na mapangalagaan. Ang paglipat ng mga quote sa kanan ay walang epekto at hindi na magdaragdag ng anumang indentation. Ang mga bloke ng teksto ay isinama sa JDK 13 bilang tampok na preview. Nangangahulugan ito na hindi pa sila kasama sa kaukulang detalye ng wikang Java. Ibig sabihin, hindi malinaw kung magiging permanenteng bahagi ng wika ang feature na ito o kung panauhin lang ito dito. Sa kasalukuyan, maaaring subukan ng mga developer ang tampok at magbigay ng kanilang opinyon dito. Ang kapalaran ng mga bloke ng teksto ay nakasalalay dito: ang tampok ay maaaring mapabuti, at kung hindi mo gusto ito, maaari itong alisin nang buo. Kung gusto mong subukan ang mga text block sa pagsasanay, tandaan na ang mga feature ng preview ay dapat na tahasang isama upang makapag-compile at tumakbo. Compilation:
Upang patakbuhin ang application, kailangan mong paganahin ang mga feature ng preview:
java --enable-preview TextBlock
Ang klase Stringay may tatlong bagong pamamaraan na umakma sa pagbabagong ito ng wika:
formatted(): Mag-format ng string gamit ang string mismo bilang format string. Katumbas ng isang hamonformat(this, args)
stripIndent(): Tinatanggal ang mga random na espasyo mula sa isang string. Kapaki-pakinabang ito kung nagbabasa ka ng mga multiline na string at gusto mong ilapat ang parehong pagbubukod ng whitespace gaya ng gagawin mo sa isang tahasang deklarasyon.
translateEscapes(): Nagbabalik ng string na may mga escape sequence (tulad ng \ r), isinalin sa naaangkop na Unicode value.
Kapansin-pansin na kakalabas lang ng mga paraang ito, ngunit minarkahan na bilang hindi na ginagamit ... ang kalagayang ito ay nagmumungkahi na maaaring alisin ang mga ito sa hinaharap na bersyon ng JDK. Tila medyo sira-sira na magdagdag ng isang bagong pamamaraan at agad itong iwanan. Gayunpaman, pakitandaan na ang mga pamamaraang ito ay nauugnay sa isang tampok na preview na maaaring baguhin o alisin. Marahil ay makakatulong ang pagpapasok ng anotasyon @PreviewFeaturesa mga ganitong sitwasyon, ngunit hindi pa ito kasama sa JDK (bagama't may mataas na antas ng posibilidad na lilitaw ito sa JDK 14).
Ipinakilala ng Java 12 ang isang panukala para sa isang bagong anyo ng pagsulat ng mga expression na may switch statement - JEP 325 . Ito ay naging pinakaunang tampok na preview at ang kapalaran nito ay nagpapatunay na ang pagsusumite ng mga panukala sa mga user ay isang magandang ideya. Bago ang JDK 12, switchmaaari lang itong gamitin bilang isang pahayag na nagsasagawa ng pagkilos ngunit hindi nagbabalik ng resulta. Ngunit sa Java 12 pinahintulutan itong magamit switchbilang isang expression na nagbabalik ng isang resulta na maaaring italaga sa isang variable. Mayroong iba pang mga pagbabago sa syntax ng mga pahayag ng kaso sa loob ng switch. Tingnan natin ang isang halimbawa mula sa JEP upang maunawaan kung paano ito gumagana.
Sa halimbawang ito, ginagamit namin ang halaga dayOfWeekupang italaga ang halaga sa numberOfLetters. Dahil sa mga kakaibang gawain ng operator switch, ang code na ito ay hindi ang pinakamaganda at madaling magkamali. Una, kung nakalimutan naming maglapat ng pahayag breaksa bawat pangkat ng mga label ng kaso, magiging default kami sa susunod na pangkat ng mga label ng kaso. Ito ay maaaring humantong sa mga error na mahirap hanapin. Pangalawa, dapat nating tukuyin ang bawat pangkat ng mga label ng kaso. Kung nakalimutan natin, kung gayon, siyempre, makakakuha tayo ng error sa compiler, gayunpaman, ang pagpipiliang ito ay hindi perpekto. Medyo verbose din ang aming code dahil ang bawat value dayOfWeekay dapat may sariling case label. Gamit ang bagong syntax, nakakakuha kami ng mas malinis at mas kaunting error-prone na code:
Ngayon kailangan lang nating gawin ang pagtatalaga (mula sa return switchvalue ng expression) at maaaring gumamit ng comma-separated list para sa mga case label. At, dahil hindi namin ginagamit ang operator break, inaalis namin ang mga problemang nauugnay dito. Ang expression na syntax switchay nagpapahintulot sa amin na gumamit ng mas lumang istilong syntax, kaya sa JDK 12 maaari naming isulat ito tulad nito:
int numberOfLetters =switch(dayOfWeek){case MONDAY:case FRIDAY:case SUNDAY:break6;case TUESDAY
break7;case THURSDAY
case SATURDAY
break8;case WEDNESDAY
break9;default:thrownewIllegalStateException("Huh?: "+ day);};
Ayon sa komunidad ng Java, ang paggamit ng overloading breakupang tukuyin ang isang return value ay maaaring nakakalito. Ang wikang Java ay nagpapahintulot din sa iyo na gumamit ng break( at continue) na may label tulad ng unconditional jump operator goto. Binago ng JEP 354 ang paggamit na ito break, kaya sa Java 13 ang aming code ay bahagyang nagbabago:
int numberOfLetters =switch(dayOfWeek){case MONDAY:case FRIDAY:case SUNDAY:yield6;case TUESDAY
yield7;case THURSDAY
case SATURDAY
yield8;case WEDNESDAY
yield9;default:thrownewIllegalStateException("Huh?: "+ day);};
Ang susunod na tatlong JEP ay nauugnay sa Java Virtual Machine.
Binibigyang-daan ka ng extension na ito na dynamic na mag-archive ng mga klase sa dulo ng pagpapatupad ng Java application. Nagbibigay-daan sa iyo ang CDS o Class Data Sharing na i-pack ang lahat ng klase na inilunsad sa startup sa isang espesyal na archive class data sharing, gamit ang listahan ng parehong mga klase bilang default. Ito ay humahantong sa isang makabuluhang acceleration sa paglulunsad ng mga application at pag-save ng RAM. Dati, ang paggamit ng AppCDS ay isang multi-step na proseso na nagsasangkot ng paggawa ng listahan ng mga nauugnay na klase at paggamit sa listahang iyon upang lumikha ng archive na gagamitin para sa mga susunod na pagtakbo. Ngayon ang kailangan lang ay isang paglulunsad ng application na may -XX: flag ArchiveClassesAtExitna nagpapahiwatig ng lokasyon kung saan isusulat ang archive. Sa diskarteng ito, ang mga klase ay awtomatikong naka-package sa isang archive pagkatapos na ihinto ang application nang normal.
JEP 351 ZGC : I-uncommit ang hindi nagamit na memorya
Isang taon na ang nakalipas, ipinakilala ng JDK 11 ang ZGC, isang pang-eksperimentong, scalable, low-latency na kolektor ng basura. Sa una, medyo kakaiba ang pagkilos ng ZGC: hindi nito pinahintulutan na maibalik ang memorya sa operating system, kahit na hindi na ito kailangan. Para sa ilang kapaligiran, gaya ng mga lalagyan, kung saan ang mga mapagkukunan ay ginagamit ng maraming serbisyo nang sabay-sabay, maaari nitong limitahan ang scalability at kahusayan ng system. Ang ZGC heap ay binubuo ng tinatawag na ZPages. Kapag na-clear ang ZPages sa panahon ng cycle ng koleksyon ng basura, ibabalik ang mga ito sa ZPageCache. Ang mga ZPages sa cache na ito ay inayos ayon sa kung gaano katagal ginamit ang mga ito. Sa Java 13, ibabalik ng ZGC sa operating system ang mga page na natukoy na hindi ginagamit sa loob ng mahabang panahon. Sa ganitong paraan maaari silang magamit muli para sa iba pang mga proseso.
Ang parehong pagpapatupad ng API java.net.Socketay java.net.ServerSocketJDK 1.0 pa rin. Dito, at lahat ng kasunod na JDK, ang pagpapatupad ng mga API na ito ay gumagamit ng ilang mga diskarte (gaya ng paggamit sa thread stack bilang isang I/O buffer) na ginagawang hindi nababaluktot at mahirap na panatilihin ang mga ito. Upang malutas ang problemang ito, isang bagong pagpapatupad ang ibinigay sa JDK 13 NioSocketImpl. Hindi na ito nangangailangan ng native code, na ginagawang mas madali ang pag-port sa iba't ibang platform. Ginagamit din ng klase na ito ang umiiral na mekanismo ng buffer cache (pag-iwas sa paggamit ng thread stack para sa layuning ito) at pag-lock java.util.concurrentsa halip na mga naka-synchronize na pamamaraan. Pasimplehin nito ang pagsasama sa mga hibla mula sa Project Loom .
Mga bagong API
Nabanggit namin kanina na ang Java 13 ay may kasamang 76 na bagong API sa mga base class na library. Sinasaklaw nila ang mga sumusunod na lugar:
Mga update sa suporta ng Unicode.
Tatlong bagong paraan Stringupang suportahan ang mga bloke ng teksto (tingnan ang paglalarawan ng JEP 255 sa itaas).
Ang mga klase java.nioay mayroon na ngayong ganap (kumpara sa kamag-anak) getat
itakda ang mga pamamaraan. Sila, tulad ng base abstract class
Buffer, ay may kasamang paraan
slice()para sa pagkuha ng bahagi ng buffer.
force()Pinipilit ng class method MappedByteBufferang isang buffer section na isulat sa backing storage nito.
nio.FileSystemnagdaragdag ng tatlong bagong overloaded na mga form newFileSystem()para sa pag-access sa mga nilalaman ng isang file bilang isang file system.
Isang bagong kawili-wiling paraan ang javax.annotation.processing.ProcessingEnvironmentlumitaw. isPreviewEnabled(). Sasabihin nito sa iyo kung pinagana ang mga feature ng preview. Ito ay kawili-wili dahil ang anotasyong binanggit sa itaas @PreviewFeatureay hindi magiging available hanggang sa mailabas ang JDK 14.
DocumentBuilderFactoryat SAXParserFactorykumuha javax.xml.parsersng tatlong bagong pamamaraan para sa paglikha ng mga pagkakataong may kamalayan sa namespace.
GO TO FULL VERSION