Coffee break #154. Tatlong uri ng mga loop sa Java. JDK 19: Bagong Java 19 na mga tampok na darating sa Setyembre

Tatlong Uri ng Mga Loop sa Java

Source: Medium Pagkatapos basahin ang post na ito, matututunan mo ang tungkol sa iba't ibang paraan ng pag-loop sa Java. Ang Loop ay idinisenyo upang magsagawa ng isang bloke ng code hanggang sa maging totoo ang isang kundisyon. Mayroong tatlong uri ng mga loop sa Java:

• habang
• gawin habang
• para sa

Habang loop

Umuulit ang while loop hanggang sa ang tinukoy na kondisyon ng Boolean ay masuri sa true. Gaya ng ipinapakita sa diagram sa ibaba, ang pahayag ay isasagawa hanggang ang pagsubok ng kondisyon ay bumalik na totoo.

Syntax

while (condition true) {
       // Блок codeа
}

Halimbawa

Dito isasagawa ang while loop hanggang ang kundisyon ay totoo para sa x na mas mababa sa 3.

public class WhileLoop {
     static int x = 1;
     public static void main(String[] args) {
         while(x < 3) {
             System.out.println("x = "+x);
             x++;
         }
     }
}

Konklusyon:

do-while loop

Ang isang do-while loop ay katulad ng isang while loop na may isang maliit na pagkakaiba. Ang do-while loop ay palaging tumatakbo nang isang beses bago subukan ang kundisyon.

Syntax

do {
     //  Блок codeа
   } while(condition);

Halimbawa

Sa halimbawang ito, makikita mo na ang do statement o block ng code ay palaging isinasagawa nang isang beses bago subukan kung totoo o mali ang kundisyon.

static int x = 5;
        public static void main(String[] args) {
            do {
                System.out.println("x = "+x);
                x++;
            } while(x < 3);
        }

Konklusyon

para sa loop

Ang for loop ay ibang-iba sa while at do-while loops. Sa isang linya ng pahayag, tinutukoy namin ang pagsisimula, kundisyon (totoo o mali), pagdaragdag/pagbawas.

Syntax

For (initialization; condition; increment/decrement) {
    // Блок codeа
}

Halimbawa

public static void main(String[] args) {
     for(int i = 0 ; i < 2 ; i++) {
         System.out.println("i = " + i);
     }
}

Konklusyon: Initialization: int i = 0 ay ang loop initialization condition. Kundisyon: Sinusuri upang makita kung totoo ang kundisyon para sa pagpapatakbo ng block o code sa loob ng for loop. Kung mali ang kundisyon, tatapusin nito ang loop. Increment/decrement: i-update ang variable para sa susunod na pag-ulit.

Pinalawak para sa loop (para sa bawat isa)

May isa pang bersyon ng for loop na mas compact at readable kaysa sa simple for loop. Ito ay tinatawag na extended para sa loop (o para sa bawat loop) at ginagamit upang umulit sa pamamagitan ng mga koleksyon at array. Ito ay magagamit sa anumang bagay na nagpapatupad ng Iterable na interface.

Halimbawa

class Main
{
    public static void main(String[] args)
    {
        int[] A = { 1, 2, 3, 4, 5 };

        for (int i: A) {
            System.out.println(i);
        }
    }
}

Konklusyon:

JDK 19: Bagong Java 19 na mga tampok na darating sa Setyembre

Source: Infoworld Narito ang isang listahan ng mga bagong feature na lalabas sa paparating na release ng JDK. Ang paglabas nito ay naka-iskedyul para sa Setyembre 20, 2022. Ang Java Development Kit 19, isang panandaliang paglabas ng suporta na dapat bayaran sa Setyembre, ay umabot na sa yugto ng paglabas ng kandidato. Mayroong pitong feature na dapat abangan: structured parallelism, record templates, preview ng foreign at memory API, at suporta para sa open-source Linux/RISC-V instruction set architecture (ISA). Dahil ang mga bagong feature ay naka-freeze na para sa JDK 19, ang iba pang mga nakaplanong feature, gaya ng mga generic at value object, ay ipinagpaliban sa mas bagong bersyon ng platform. Karaniwan ang isang bagong bersyon ng Java ay inilabas tuwing anim na buwan. Na-publish ang JDK 19 release candidate noong Agosto 11, kasunod ng dalawang rampdown release noong Hunyo at Hulyo. Ang pangalawang kandidato sa paglabas ay inaasahan sa ika-25 ng Agosto. Maaaring ma-download ang mga maagang build ng JDK 19 mula sa jdk.java.net/19 . Kasama sa mga tampok ng JDK 19 ang:

• Structured parallelism (sa panahon ng incubation phase). Dinisenyo ito para gawing simple ang multi-threaded programming gamit ang Structured Concurrency API. Itinuring ng paralelismong ito ang maraming gawain na tumatakbo sa iba't ibang mga thread bilang isang yunit ng trabaho. Alinsunod dito, pasimplehin nito ang paghawak at pagkansela ng error, at mapapabuti rin ang pagiging maaasahan.

• Preview ng mga template ng talaan (para sa pag-parse ng mga halaga ng tala). Ang mga pattern ng pag-record at mga pattern ng uri ay maaari na ngayong i-nested, na nagbibigay ng isang deklaratibo, makapangyarihan, at composable na paraan ng nabigasyon at pagmamanipula ng data. Kasama sa bagong feature ang pagpapalawak ng pagtutugma ng pattern upang magpahayag ng mas kumplikadong mga query ng compound data nang hindi binabago ang syntax o semantics ng mga pattern ng uri.

  Bumubuo ang pagbabagong ito sa pagtutugma ng pattern para sa halimbawa ng ipinakilala sa JDK 16 noong Marso 2021. Maaaring kailanganin ng mga release sa hinaharap na palawigin ang mga template ng record na may mga feature tulad ng mga template ng array at mga template ng vararg.

  Ang mga template ng post ay bahagi ng proyektong Amber , na naglalayong galugarin at bumuo ng maliliit, na nakatuon sa pagganap na mga tampok ng Java.

• I-preview ang mga bersyon ng foreign at memory API function . Ang bagong release ay magpapakilala ng isang API na nagpapahintulot sa mga Java program na makipag-ugnayan sa code at data sa labas ng Java runtime. Sa pamamagitan ng mahusay na pagtawag sa mga third-party na function (iyon ay, code sa labas ng JVM) at secure na pag-access sa dayuhang memorya (memorya na hindi pinamamahalaan ng JVM), papayagan ng API ang mga programa ng Java na tumawag sa mga katutubong aklatan at magproseso ng katutubong data nang walang mga kakulangan ng Java Native Interface (JNI).

  Pinagsasama ng foreign at memory API ang dalawang naunang incubation API: ang external memory access API at ang external linker API. Ang dayuhang function at memory API ay dati nang na-incubate sa JDK 17 at muling na-incubate sa JDK 18.

• Preview ng mga Virtual na thread. Ang tampok na ito ay nagpapakilala ng magaan na mga thread na lubos na nakakabawas sa pagsusumikap sa pagsulat, pagpapanatili, at pagsubaybay sa mga parallel na application na may mataas na pagganap. Ang layunin ng inobasyon ay magbigay ng kakayahang sukatin ang mga application ng server na nakasulat sa isang simpleng istilo ng thread-per-request. Tina-target ng feature ang code na gumagamit ng java.lang Thread API para mag-inject ng mga virtual na thread na may kaunting pagbabago, at mag-troubleshoot, mag-debug, at mag-profile ng mga virtual na thread gamit ang mga kasalukuyang tool ng JDK.

• Pangatlong preview ng pagtutugma ng pattern para sa mga switch expression at statement. Pinapalawak nito ang pagtutugma ng pattern upang lumipat, na magbibigay-daan sa isang expression na masuri laban sa isang bilang ng mga pattern, bawat isa ay may partikular na epekto, kaya ang mga kumplikadong query na nakasentro sa data ay maaaring maipahayag nang maikli at ligtas.

  Dati nang na-preview ang feature na ito sa JDK 17 at JDK 18. Ang ikatlong preview ay nagdaragdag ng mga pagpapahusay, kabilang ang pagpapalit ng protektado kapag may mga pattern na may mga clause sa switch block. Bilang karagdagan, ang runtime semantics ng switch pattern kapag ang value ng selector expression ay null ay sumusuporta na ngayon sa legacy switch semantics.

  Palalawakin ng inobasyon ang pagpapahayag at pagiging angkop ng mga expression at operator ng switch sa pamamagitan ng pagpayag na lumitaw ang mga pattern sa mga label ng kaso. Bibigyan din nito ang mga developer ng kakayahang i-relax ang makasaysayang poot sa mga null at switch kapag kinakailangan, pagbutihin ang kaligtasan ng mga switch statement, at tiyakin na ang mga kasalukuyang switch statement at statement ay patuloy na mag-compile nang hindi nagbabago at ipapatupad na may magkakaparehong semantics.

• Ikaapat na pagpapapisa ng itlog ng vector API . Ipapahayag nito ang mga vector computations na mapagkakatiwalaang mag-compile sa runtime sa pinakamainam na mga tagubilin sa vector sa mga sinusuportahang arkitektura ng processor. Magbibigay ito ng mas mahusay na pagganap kaysa sa katumbas na mga kalkulasyon ng scalar. Nagkakaroon ang mga developer na gumagamit ng API ng kakayahang magsulat ng mga kumplikadong vector algorithm sa Java gamit ang autovectorizer ng HotSpot, ngunit may custom na modelo na ginagawang mas predictable at maaasahan ang vectorization. Ang Vector API ay dating incubated sa JDK 16, JDK 17, at JDK 19.

  Ang Vector API ay magpapalawak ng bitwise integral na mga linear na operasyon, kabilang ang mga pagpapatakbo tulad ng pagbibilang ng bilang ng mga bit ng isa, pag-reverse ng pagkakasunud-sunod ng mga bit, at pag-compress at pagpapalawak ng mga bit.

• Ang Linux/RISC-V Java port ay makakakuha ng hardware instruction set support na sinusuportahan na ng malawak na hanay ng mga toolkit ng wika. Susuportahan na ngayon ng Linux/RISC-V port ang RV64GV RISC-V configuration, isang 64-bit general purpose ISA na may kasamang mga tagubilin sa vector.

  Susuportahan din ng port ang sumusunod na mga opsyon sa virtual machine ng HotSpot: template interpreter, C1 JIT compiler (client), C2 JIT compiler (server), at lahat ng kasalukuyang pangunahing kolektor ng basura, kabilang ang ZGC at Shenandoah.