Tsükkel on programmi fragment, mis kordub mitu korda.

Javas on kahte tüüpi silmuseid: tüüp "while" ja tüüp "n-time".

Esimest tüüpi „saamise ajal” on loodud teatud toimingu kordamiseks seni, kuni mõni tingimus on täidetud. Näide: suurendage arvu 5 võrra, kuni see jõuab kolme numbrini.

Teist tüüpi “n-time” on ette nähtud teatud toimingute kordamiseks etteantud arv kordi. Näide: korrutage arv iseendaga 4 korda.

While loop (while ja do...while avaldused)

Avaldus while kordab määratud toiminguid seni, kuni selle parameeter on tõene.

Näiteks käivitatakse selline silmus 4 korda ja ekraanil kuvatakse "1 2 3 4":

Int i = 1; kuni ma< 5) { System.out.print(i + " "); i++; }

Sellist tsüklit ei käivitata isegi üks kord ja ekraanil ei kuvata midagi:

Int i = 1; kuni ma< 0) { System.out.print(i + " "); i++; }

See tsükkel kestab lõputult ja ekraanil kuvatakse "1 2 3 4 5 6 7...":

Int i = 1; while (true) (System.out.print(i + " "); i++; )

Tingimust, mis määrab, kas tsüklit korratakse, kontrollitakse enne tsükli iga sammu, sealhulgas esimest. Nad ütlevad, mis toimub eelkontroll tingimused.

Seal on tsükkel nagu "bye" with järelkontroll tingimused. Selle kirjutamiseks kasutatakse lausete do...while konstruktsiooni.

Seda tsüklit teostatakse 4 korda ja ekraanil kuvatakse "2 3 4 5":

< 5);

Seda tsüklit teostatakse 1 kord ja ekraanil kuvatakse "2":

Int i = 1; do ( i++; System.out.print(i + " "); ) while (i< 0);

Silmuse do...while keha täidetakse vähemalt korra. Seda operaatorit on mugav kasutada, kui mõnda programmi toimingut tuleb teha vähemalt üks kord, kuid teatud tingimustel tuleb seda mitu korda korrata.

Kontrollige järgmist programmi (see arvab segmendist ära juhusliku täisarvu ja palub kasutajal see ära arvata, sisestades klaviatuurilt valikud, kuni kasutaja arvab numbri ära, küsib programm talt, kas arvatud arv on rohkem või vähem kui kasutaja sisestatud):

Impordi java.util.Scanner; public class Main ( public static void main(String args) ( // prog - programmi loodud arv // kasutaja - kasutaja sisestatud arv int prog, user; // Loo juhuslik täisarv vahemikus 1 kuni 10 prog = (int)(Math. random() * 10) + 1 System.out.println("Ma arvasin ära numbri 1 kuni 10, arva ära." System.out.print("Sisestage oma number: ") ; System.in); // Kontrollige, kas sisendvoos on täisarv if(input.hasNextInt()) ( do ( // Lugege täisarv sisendvoost user = input.nextInt(); if(user = = prog) ( System.out.println("Sa arvasid ära!"); ) else ( // Kontrollige, kas arv sisaldub segmendis if (kasutaja > 0 && kasutaja<= 10) { System.out.print("Вы не угадали! "); // Если число загаданное программой меньше... if(prog < user) { System.out.println("Моё число меньше."); } else { System.out.println("Моё число больше."); } } else { System.out.println("Ваше число вообще не из нужного отрезка!"); } } } while(user != prog); } else { System.out.println("Ошибка. Вы не ввели целое число!"); } System.out.println("До свиданья!"); } }

Tehke programmis järgmised muudatused:

Programm ei peaks mõtlema arvule mitte segmendist , vaid täisarvu lõigust alates [−10;10], välja arvatud null. Samal ajal proovige jälgida, et programmi genereeritud juhuslike arvude jaotus oleks ühtlane (st kui null välja kukub, ei saa seda lihtsalt asendada mõne muu arvuga, näiteks 1-ga, sest siis on 1 langesid kaks korda suurema tõenäosusega kui ülejäänud numbrid).

Programm peaks andma kasutajale teada, et ta tegi märgis vea, kui programm arvas positiivse arvu ja kasutaja sisestas negatiivse. Ja vastupidi.

N-aja tsükkel (lause jaoks)

For-lause sisaldab kolme parameetrit. Esimest nimetatakse initsialiseerimiseks, teist nimetatakse kordustingimuseks ja kolmandat nimetatakse iteratsiooniks.

For (initsialiseerimine; tingimus; iteratsioon) ( //tsükli keha, st tsükliliselt korduvad toimingud)

Esimeses parameetris valite tavaliselt mõne muutuja, mida kasutatakse tsükli korduste arvu loendamiseks. Seda nimetatakse loenduriks. Loendurile antakse mingi algväärtus (need näitavad, millisest väärtusest see muutub).

Teine parameeter näitab loenduri mõningaid piiranguid (näidake, millise väärtuseni see muutub).

Kolmas parameeter määrab avaldise, mis muudab loendurit pärast iga tsükli sammu. Tavaliselt on see kasv või kahanemine, kuid võite kasutada mis tahes avaldist, kus loendurile määratakse uus väärtus.

Enne silmuse esimest sammu omistatakse loendurile algväärtus (käivitatakse). See juhtub ainult üks kord.

Enne tsükli iga sammu (kuid pärast initsialiseerimist) kontrollitakse kordustingimust, kui see on tõene, siis käivitatakse uuesti tsükli keha. Samal ajal ei pruugi tsükli kehaosa käivitada isegi üks kord, kui tingimus on esimese kontrollimise ajal vale.

Pärast tsükli iga sammu lõpetamist ja enne järgmise alustamist (ja seega enne kordustingimuse kontrollimist) viiakse läbi iteratsioon.

Järgmine programm kuvab numbreid 1 kuni 100:

Sest (int i = 1; i<= 100; i++) { System.out.print(i + " "); }

Järgmine programm kuvab numbreid vahemikus 10 kuni –10:

For (int s = 10; s > -11; s--) ( System.out.print(s + " "); )

Esitatud programm kuvab paarituid numbreid 1 kuni 33:

Sest (int i = 1; i<= 33; i = i + 2) { System.out.print(i + " "); }

Esitatud programm arvutab jada 2, 4, 6, 8,... 98, 100 fragmendi elementide summa.

Int summa = 0; // Kogume siia tulemuse (int j = 2; j

Esitatud programm tõstab muutujast arvu a loomulikul määral muutujast n:

Topelt a = 2; int n = 10; topeltres = 1; // Kogume siia tulemuse (int i = 1; i<= n; i++) { res = res * a; } System.out.println(res);

Esitatud programm kuvab jada 2n+2 10 esimest elementi, kus n=1, 2, 3…:

Sest (int i = 1; i< 11; i++) { System.out.print(2*i + 2 + " "); }

Esitatud programm kuvab jada 2a n−1 +3 10 esimest elementi, kus a 1 =3:

Int a = 3; jaoks (i=1; i<=10;i++) { System.out.print(a + " "); a = 2*a + 3; }

Ühe tsükli jooksul saate korraga seadistada mitu loendurit. Sel juhul eraldatakse mitu iteratsiooni ja initsialiseerimise avaldist komadega. Määrata saab ainult ühe kordustingimuse, kuid see võib olla avaldis, mis sisaldab korraga mitut loendurit.

Esitatud programm kuvab jada 2a n-1 -2 10 esimest elementi, kus a 1 =3:

Sest (int a=3, i=1; i<=10; a=2*a-2, i++) { System.out.print(a + " "); }

Esitatud programm kuvab järgmise jada "0 -1 -4 -9 -16 -25":

Sest (int a=0, b=0; a-b<=10; a++, b--) { System.out.print(a*b + " "); }

Silmuse varajane lõpetamine (break lause)

Nii "while" tüüpi tsüklit kui ka "n-time" tüüpi tsüklit saab varakult lõpetada, kui helistate tsükli kehas olevale operaatorile murda. Sel juhul väljub tsükkel kohe, isegi praegust sammu ei lõpetata (st kui pärast pausi oli muid avaldusi, siis neid ei täideta).

Järgmise näite tulemusel kuvatakse ekraanil ainult numbreid “1 2 3 4 End”.

Sest (int a=1; a

Kui programm käivitab tsükli viiendat korda (siseneb tsüklisse, mille loendur on 5), kontrollitakse kohe katkestuse lause täitmise tingimust ja see leitakse olevat tõene. Ülejäänud osa silmuse kehast (ekraanile väljund) enam ei toodeta: programm jätkab kohe pärast tsüklit ja pärast seda määratud toiminguid.

Breaklause abil saate katkestada ilmselgelt lõpmatu tsükli. Näide (ekraanil kuvatakse "100 50 25 12 6 3 1 0" ja pärast seda tsükkel peatub):

Int s = 100; while (true) (System.out.print(s + " "); s = s / 2; if(s == 0) ( break; ) )

Katkestusoperaatorile on mõtet helistada ainult siis, kui mõni tingimus ilmneb, vastasel juhul valmib tsükkel juba esimesel etapil enne tähtaega.

Int a; for (a=25; a>0; a--) ( break; System.out.print(a + " "); ) System.out.print("a=" + a);

Ülaltoodud näites väljund ekraanile silmuses ei esine isegi üks kord ja kui muutuja a pärast tsüklit kuvatakse ekraanil, selgub, et selle väärtus pole kunagi muutunud, st kuvatakse “a=25” (ja ei midagi enamat).

Pange tähele ka seda, et muutuja deklareeriti enne tsükli algust. Kui muutuja on tsükli parameetrites deklareeritud, osutub see väljaspool seda kättesaamatuks, kuid sel juhul oli vaja midagi muud - teada saada, milline väärtus on loenduril pärast tsükli lõppu.

Ülesanded

Looge programm, mis kuvab kõik neljakohalised numbrid järjestuses 1000 1003 1006 1009 1012 1015….

Koostage programm, mis kuvab jada 1 3 5 7 9 11 13 15 17 esimesed 55 elementi.

Koostage programm, mis kuvab jada kõik mittenegatiivsed elemendid 90 85 80 75 70 65 60….

Koostage programm, mis kuvab jada esimesed 20 elementi 2 4 8 16 32 64 128 ….

Kuvage kõik jada 2a n-1 -1 liikmed, kus a 1 =2, mis on väiksemad kui 10000.

Kuvage jada 2a n-1 +200 kõik kahekohalised liikmed, kus a 1 = -166.

Loo programm, mis arvutab välja naturaalarvu n faktoriaali, mille kasutaja sisestab klaviatuurilt.

Kuvatakse kõik kasutaja poolt klaviatuurilt sisestatud naturaalarvu positiivsed jagajad.

Kontrollige, kas kasutaja poolt klaviatuurilt sisestatud naturaalarv on algarv. Püüdke mitte teha tarbetuid toiminguid (näiteks kui olete leidnud vähemalt ühe mittetriviaalse jagaja, on juba selge, et arv on liit ja kontrollimist pole vaja jätkata). Arvestage ka seda, et naturaalarvu n väikseim jagaja, kui see üldse olemas on, peab paiknema segmendis.

Koostage programm, mis kuvab jada 2a n-2 -2 12 esimest elementi, kus a 1 =3 ja a 2 =2.

Kuvage Fibonacci jada 11 esimest liiget. Tuletame meelde, et jada esimene ja teine ​​liige on võrdsed ühega ning iga järgmine on kahe eelneva summa.

Kasutaja poolt klaviatuurilt sisestatud naturaalarvu puhul arvutage välja kõigi selle numbrite summa (pole ette teada, mitu numbrit numbris on).

Linnas N toimub trammiga sõitmine paberilt ärarebitavate piletitega. Igal nädalal tellib trammidepoo kohalikust trükikojast piletirulli numbritega 000001 kuni 999999. Pilet loetakse “õnnelikuks”, kui numbri kolme esimese numbri summa on võrdne kolme viimase numbri summaga. numbrid, nagu näiteks piletitel numbritega 003102 või 567576. Trammidepoo otsustas kinkida iga õnneliku pileti võitjale meene ja mõtleb nüüd, kui palju meeneid vaja läheb. Loe programmi abil kokku, mitu õnnelikku piletit on ühes rullis?

N-linnas on suur ladu, milles on 50 000 erinevat riiulit. Töötajate mugavuse huvides otsustas lao juhtkond tellida kohalikust trükikojast igale riiulile plaadi numbriga 00001 kuni 50000, kuid plaatide trükkimisel selgus, et trükimasin rikke tõttu ei printinud numbrit 2, seega kõik tahvlid, mille numbrid sisaldasid ühte või mitut kahte (näiteks 00002 või 20202), peate selle uuesti tippima. Kirjutage programm, mis loendab, kui palju neid vigaseid plaate oli defektses partiis.

Elektrooniline kell näitab aega formaadis 00:00 kuni 23:59. Loendage, mitu korda päevas juhtub, et käärsoolest vasakul kuvatakse sümmeetriline kombinatsioon käärsoolest paremal asuva kombinatsiooniga (näiteks 02:20, 11:11 või 15:51).

Ameerika armees peetakse õnnetuks numbrit 13 ja jaapanlastel 4. Enne rahvusvahelisi õppusi otsustas Vene armee peakorter välja jätta arvud 4 või 13 sisaldava sõjavarustuse arvu (näiteks 40123, 13313, 12345 või 13040), et välismaa kolleege mitte segadusse ajada. Kui armee käsutuses on 100 tuhat ühikut sõjatehnikat ja igal lahingumasinal on number 00001 kuni 99999, siis mitu numbrit tuleb välja jätta?

2010, Aleksei Nikolajevitš Kostin. Moskva Riikliku Pedagoogikaülikooli matemaatikateaduskonna TIDM-i osakond.

12.08.17 1,9K

Java While Do tsükkel on avaldus, mis võimaldab teil sama koodijuppi mitu korda käivitada. Seda tsüklit saab kasutada toimingute kordamiseks, kui tingimused on täidetud.

Kuigi Loop

Kuigi tsüklit on Java keeles kõige lihtsam konstrueerida. See koosneb ajaklahvist, tsükli tingimusest ja tsükli kehast:

while (tingimus) ( // loop body )

Silmuskeha iga eraldi käitamist peetakse iteratsiooniks. Enne iga iteratsiooni hinnatakse tsükli tingimusi. Selle keha täidetakse ainult siis, kui tsükli tingimus on tõene.

Silmuse iteratsioonid muudavad midagi ja teatud hetkel tagastab tingimuste hindamine false , mille järel tsükkel lõpeb. Silmust, mille tingimus ei tagasta kunagi valet, täidetakse lõpmatu arv kordi. Selliseid tsükleid nimetatakse lõpututeks.

Näide

int arv = 0; samas (nr< 10) { System.out.println(num); num++; }

See näide prindib numbrid 0 kuni 9. Vaatame koodi samm-sammult läbi. Esmalt initsialiseerime muutuja num väärtusega 0. Sellest saab silmusloendur. Kui programm jõuab hetkeni , hinnatakse tsükli tingimusi. Meie puhul 0< 10 возвращает значение true и исполняется тело цикла. Внутри цикла выводится переменная num , а затем увеличивается на 1 . На этом завершается первая итерация.

Pärast esimest "käivitamist" hinnatakse Java While tsükli tingimust teist korda. 1< 10 по-прежнему возвращает true , после чего запускается следующая итерация цикла. Один и тот же процесс повторяется несколько раз.

Viimane iteratsioon algab siis, kui num väärtus võrdub 9-ga. Silmusloendurit kuvatakse viimast korda ja väärtust suurendatakse 10-ni. Seekord ei saa uut iteratsiooni alustada, kuna silmuse tingimus on väär . Kuna 10 ei ole väiksem kui 10.

Seega töötab tsükkel seni, kuni tsükli tingimus on täidetud. Nende teadmiste abil saate luua keerukamaid ja funktsionaalsemaid silmuseid. Kordame massiivi:

Stringinimed = ("Doc", "Dopey", "Bashful", "Grumpy", "Sneezy", "Sleepy", "Happy"); int indeks = 0; samas (indeks< names.length) { System.out.println(names); index++; }

Selle näite kontseptsioon on sarnane eelmisega. Initsialiseerime tsükliloenduri ja kordame massiivi, kuni kõik elemendid on prinditud. Seetõttu on massiivide itereerimine üsna tavaline juhtum ja Java-l on selleks parem konstruktsioon: For silmus.

do-while silmus

Java while do tsükkel sarnaneb while-ga, kuid sellel on oluline erinevus: erinevalt while-st kontrollitakse tingimust iga iteratsiooni lõpus. See tähendab, et do-while tsüklit käivitatakse alati vähemalt üks kord:

do ( // loop body ) while (tingimus);

Näide

do-while käivitab esmalt tsükli keha ja hindab seejärel selle tingimusi. Olenevalt saadud tulemusest tsükkel peatub või algab järgmine iteratsioon. Vaatame lihtsat mängu "arva ära nimi":

Skänneri skanner = uus skanner (System.in); String arvamine; do ( System.out.print("Arva ära nimi: "); arva = skanner.nextLine(); ) while (!"Daffy Duck.equals(arvamine)); System.out.println("Palju õnne! Sa arvasid mu nime!");

Kui Java näide kasutab faili system.ini sisendi sõelumiseks skannerit. See on standardne sisendkanal, mis enamikul juhtudel klaviatuuriga suhtleb. Lihtsamalt öeldes loeme lihtsalt teksti, mille mängija sisestab.

Mängus peate vähemalt korra kasutajalt küsima ja tegema seda seni, kuni mängija sisestab õiged vastused. Do-while silmus sobib sellisteks puhkudeks ideaalselt. Silmuse kehas saame kasutaja väärtuse ja seejärel kontrollime vastuse õigsust. Silmus peaks kulgema seni, kuni kasutaja sisendväärtus võrdub Daffy Duckiga. Õige vastuse saamisel tsükkel peatub ja õnnitleme mängijat võidu puhul.

Kokkuvõtteks

Java, kuigi tõelised tsüklid võimaldavad teil koodiosi mitu korda uuesti kasutada. Täna tutvustati meile Java while ja do-while ahelaid. Need on sarnased selle poolest, et kontrollivad tingimusi ja täidavad tsükli põhiosa, kui tingimus on tõene. Kuid samal ajal on neil oluline erinevus: while-tsükli seisukorda kontrollitakse enne iteratsiooni ja do-while-tsükli seisukorda kontrollitakse iga iteratsiooni lõpus. See tähendab, et do-while tsükkel käivitatakse alati vähemalt korra.

See väljaanne on tõlge artiklist " Java While ja Do-While tsüklid viie minutiga", mille valmistas ette sõbralik projektimeeskond

Selles õpetuses õpime, kuidas oma koodi osi kontrollitult uuesti käivitada, vaadates erinevat tüüpi silmuseid Java. Vaatame tsükleid lähemalt: samas, tee-samas, jaoks. Püüame kindlaks teha, millistel juhtudel milline tsükkel on kasutamiseks sobivaim.

Seejärel vaatame lühidalt juhuslike arvude teemat ( juhusliknumbrid). Vaatame edasi Java- Klass Juhuslik ja kuidas see võib meid mängus aidata.

Silmus, nagu nimigi ütleb, on viis sama koodijupi täitmiseks nii mitu korda kui vaja (ilma, et peaks tingimata kordama tsüklis koodi täitmise tulemust). Tsükli korduste arvu saab kas eelnevalt kindlaks määrata või programmeerijale endale teadmata. Vaatleme peamisi silmusetüüpe, mida keel meile kasutamiseks pakub. Java. Ja siis tutvustame mõnda neist oma mängu, parandades seda.

Kuigi Loop

Tsükkel samas on kõige lihtsama süntaksiga. Pea meeles kui-juhised, mida uurisime veidi varem. Operaatori tingimusavaldisesse kui(mis on sõna järel sulgudes kui) saate sisestada peaaegu igasuguse operaatorite ja muutujate kombinatsiooni. Kui avaldis on tõene ( tõsi), seejärel ploki kehasse lisatud kood kui valmib. Samamoodi ahelas samas paneme avaldise, mida saab hinnata tõsi või vale nagu on näidatud selles koodis:

Int x = 10; while(x > 0)( x--; //x vähendatakse ühe tsükli igal läbimisel)

Mis siin toimub? Esimene asi väljaspool ahelat samas deklareerisime muutuja x tüüp int ja määras sellele muutujale väärtuse "10". Siis algab tsükkel samas, mille tingimustel see on kirjutatud “ x > 0"– see tähendab, et tsükli kehasse kirjutatud kood samas täidetakse nii kaua kui muutuja x rohkem 0 ja tingimus ei saavuta väärtust vale. Seetõttu käivitatakse kood 10 korda (x=10,x>0; x=9,x>0; x=8,x>0; x=7,x>0; x=6,x>0; x=5,x>0 x=4,x>0; Tsükli esimesel läbimisel x = 10, teises juba 9 , kolmandas 8 jne. Ja millal x saab olema võrdne 0 , siis tsüklisse sisenemise tingimus ei ole täidetud ja programm jätkab järgmisest reast pärast tsükli lõppu.

Sama mis operaatoris kui, on võimalik olukord, kus tsüklit ei käivitata isegi üks kord. Heitke pilk järgmisele näitele.

Int x = 10; while(x > 10)( //mingi kood //kuid seda ei käivitata kunagi, kui x on suurem kui 10)

Lisaks pole tingimusavaldise keerukusel ega tsükli kehasse kirjutatava koodi hulgal mingeid piiranguid:

Int playerLives = 3; int tulnukat Laevad = 10; while(playerLives >0 && alienShips >0)( //Kogu mängu kood siin //... //... // jne ) //programm jätkub siin, kui kas playerLives või alienShips = 0

See tsükkel kestab kuni kas muutujani playerLives, või tulnukate laevad ei ole võrdne nulliga ega sellest väiksem. Niipea, kui üks neist tingimustest ilmneb, võtab tingimuse avaldis väärtuse vale ja programm jätkab pärast tsükli lõppemist järgmisest reast.

Väärib märkimist, et kui programm siseneb tsükli kehasse, käivitatakse see isegi siis, kui tsükli tingimus muutub vale, kusagil silmuse kehas, sest seisundit kontrollitakse ainult sisenemisel:

Int x = 1; while(x > 0)( x--; //x on nüüd võrdne 0-ga ja tingimus järgmisel korral on väär //Aga see rida täidetakse //Ja see //Ja isegi see)

Ülaltoodud näites täidetakse tsükli keha üks kord. Lisaks saate seada tingimuse, et silmus töötab igavesti - seda nimetatakse lõputu tsükkel. Siin on näide:

Int x = 0; while(true)( x++; //Ma saan väga suureks!)

Nende tsükli väljund. Märksõna murda

Mis siis, kui meil on tõesti vaja kasutada lõpmatut tsüklit, kuid nii, et saaksime otsustada, millisel hetkel sellest väljuda. Sel eesmärgil sisse Java seal on märksõna murda. Saame kasutada murda kui peame tsüklist "väljuma":

Int x = 0; while(true)( x++; //Ma muutun väga suureks! break; //Ei, sa ei tee seda! //Siinse koodini ei jõuta)

Kindlasti olete juba aimanud, et on võimalik kombineerida erinevaid otsustusvahendeid, nt kui,muidu,lüliti meie ahela sees samas ja muud tsüklid, mida me allpool käsitleme. Nt:

Int x = 0; int tooBig = 10; while(true)( x++; //Ma muutun väga suureks! if(x == tooBig)( break; //Ei, sa ei tee seda. ) //Siinne kood on saadaval seni, kuni x on 10)

Me võime veel palju erinevaid variatsioone kirja panna, kuid meie jaoks on olulisem nende teadmiste praktiline rakendamine, nii et me ei süvene praegu. Vaatame veel ühte kontseptsiooni, mida saab tsüklis manipuleerida.

Märksõna jätka

jätka töötab peaaegu samamoodi nagu murda. Märksõna jätka lööb teid tsükli kehast välja, kuid testib seejärel tingimuse avaldist, mitte ei jätka tsükli sulgevast lokkis sulust, nagu juhtuks murda. Järgmine näide näitab kasutamist jätka:

Int x = 0; int tooBig = 10; int tooBigToPrint = 5; while(true)( x++; //Ma muutun väga suureks! if(x == liigaBig)( break; ) //Ei, te ei tee seda. //Siinne kood on saadaval ainult seni, kuni x on 10 if(x > = tooBigToPrint)( //ei prindita enam ekraanile, kuid tsükkel jätkub; ) //siin olev kood on saadaval seni, kuni x võrdub 5-ga //kood x ekraanile printimiseks )

Selgitus: deklareerime ja initsialiseerime muutujad. Me läheme tsüklisse ja lisame muutuja väärtuse xüksus (nüüd x= 1). Kontrollige "Kas 1 võrdub 10?" — vale- esimene operaator kui ei täideta. Järgmine kontroll on "Kas 1 on suurem kui 5 või võrdne sellega?" — vale- teine ​​operaator kui ei täideta. Me väljastame x ekraanile.

Mõelgem võimalusele millal x võtab tsüklisse sisenemisel väärtuse 5. Me läheme tsüklisse ja lisame muutuja väärtuse xüksus (nüüd x= 6). Märkige "6 võrdub 10?" — vale- esimene operaator kui ei täideta. Järgmine kontroll on "6 on suurem kui 5 või võrdne sellega?" — tõsi- me läheme kehasse kui — jätka, väljuge ahelast ja kontrollige tsüklisse sisenemise tingimust.

Nüüd on valik millal x võtab tsüklisse sisenemisel väärtuse 9. Me läheme tsüklisse ja lisame muutuja väärtuse xüksus (nüüd x= 10). Kontrollige "Kas 10 on võrdne 10-ga?" — tõsi- me läheme kehasse kui — murda, väljuge tsüklist ja kood jätkub tsükli sulgevast lokkis sulust samas.

do-while silmus

Peaaegu sama, mis eelmine silmus, välja arvatud üks omadus - tingimusavaldise täitmise kontroll toimub pärast tsükli keha. See tähendab, et tsükkel tee-samas täidetakse alati vähemalt üks kord. Vaadake näidet:

Int x = 0; do ( x++; ) while(x< 10); //x теперь = 10

Märksõnad murda,jätka

silmuse jaoks

Tsükkel jaoks on keerulisema süntaksiga kui samas Ja tee-samas, kuna selle lähtestamiseks on vaja veidi rohkem manipuleerimist. Vaatame kõigepealt seda ja siis võtame lahti:

For(int i = 0; i< 10; i++){ //Что-то, что должно произойти 10 раз будет записано здесь }

Kuidas koostaja seda näeb? Nagu nii:

For(deklaratsioon ja lähtestamine; tingimus; muutus pärast iga tsükli läbimist)( // tsükli põhiosa)

• Deklareerimine ja initsialiseerimine– lõime uue tüübimuutuja int Koos nimega i ja määras sellele väärtuse 0 ;
• Seisund– sarnaselt teiste varem käsitletud tsüklitega kontrollime siin tsüklisse sisenemise tingimust. Kui väärtus arvutatakse järgmiselt tõsi, siis siseneme silmuse kehasse;
• Muuda pärast iga tsüklit- ülaltoodud näites i++ tähendab, et pärast tsükli järgmist läbimist jõuame muutuja väärtuseni i lisage üks (1). Lisaks saame kirjutada muutuja ja muutmises i— ühe lahutamiseks, näiteks:

for(int i = 10; i > 0; i--)( //tagasiloendus ) //käivitusklahv, i = 0

Märksõnad murda,jätka saab kasutada ka selles tsüklis.

Tsükkel jaoks võtab kontrolli initsialiseerimise, seisundi testimise ja muutuja muutmise üle. Proovime seda tsüklit praktikas oma rakenduses kohe pärast tutvumist juhuslikud arvud Ja meetodid.

Nagu peaaegu igas programmeerimiskeeles, on ka Java-l tööriistad, mis on loodud teatud koodijupi ikka ja jälle kordamiseks. Selliseid tööriistu nimetatakse tavaliselt tsükliteks. Javas on silmuseid esindatud lausetega, nagu while ja for ning nende variatsioonid. Tsükleid kasutatakse tavaliselt ühe- ja mitmemõõtmeliste massiivide ja andmestruktuuride läbimiseks, et leida konkreetseid elemente ja teha nendega edasisi toiminguid. Kuid see pole kaugeltki ainus viis sellise tööriista nagu Java silmus kasutamiseks. Kasutusnäited esitatakse nende ülevaatamisel.

Java while loop: kirjeldus ja näited

Kuigi on Java põhiline silmuseoperaator. Selle kehasse suletud koodifragmenti korratakse seni, kuni pärast seda sulgudes oleva avaldise tingimus vastab tegelikule väärtusele. Operaatori while on üldiselt järgmine vorm: while (tingimus)(//silmuse keha). Kui Boole'i ​​tingimus ei vasta enam tõele, lõpetab tsükli kehas oleva koodi täitmise. Juhtimine viiakse üle kohe pärast seda tulevale reale. Kui tsükli põhiosa sisaldab ainult ühte väidet, võite lokkis sulgud ära jätta. Programmeerijate seas peetakse aga heaks vormiks neid alati seadistada. Vaatame näidet:

Avalik klass demo (

System.out.println (“Numbrite trükkimine 1 kuni 10”);

samas (loenda<=10) {

System.out.println(count);

Algselt deklareeritud muutujate arv on väärtusega 1. Järgmisena näeme loogilist avaldist, mis on sulgudes pärast operaatori nime. Kui väärtus on tõene, tagastab tsükkel tõene, kuni loendusmuutuja väärtus on võrdne või väiksem kui 10. Iga läbimise või iteratsiooni korral suurendatakse muutuja väärtust 1 võrra ja prinditakse konsooliekraanile. Kui muutuja väärtus jõudis väärtuseni 11, tsükkel lõppes. Kui loendusmuutuja väärtus oleks algselt võrdne 11-ga, oleks tsükli tingimus vale. Programm ei siseneks isegi kehasse. Tuleb märkida, et Java süntaks võimaldab kasutada While-lauset ilma kehata. Mõelge järgmisele näitele. Oletame, et teil on kaks muutujat: i=100 ja j=200. Meie ees on ülesanne arvutada programmiliselt nende aritmeetiline keskmine.

While(++i<- — j);

Selle toimingu tulemusena on nende kahe muutuja väärtus võrdne nende algväärtuste keskmisega. Nagu näete selles näites, töötas silmus ilma kehata hästi ja tegi tingimusavaldises kõik vajalikud toimingud.

do-while silmus

Eelmistes näidetes, kui tingimusavaldis tagastas vale, ignoreeris programm tsükli keha ja jätkas edasist täitmist. Kuid mõnikord tuleb ette olukordi, kus tsükli kehas sisalduv kood tuleb käivitada vähemalt üks kord, olenemata tingimusavaldise õigsusest. Teisisõnu, mõnikord juhtub, et peate kontrollima tingimusavaldise õigsust tsükli alguses, mitte lõpus. Sarnaseid funktsioone võib pakkuda ka while-tsükli variatsioon, koodnimega do-while. Sellel on järgmine vorm: do (//loop body) while (tingimus). Nagu näete, käivitatakse siin kõigepealt tsükli keha ja seejärel kontrollitakse tingimuse tõesust. Seda tehakse igal iteratsioonil. Ülaltoodud kood töötab ligikaudu samamoodi nagu while puhul. Kuid kui seame loenduse 11-ks, käivitataks tsükli keha ikkagi üks kord, enne kui lause saaks avaldise õigsust testida.

Näited ja kirjeldus: for – Java tsükkel

For-silmus on Java keele universaalne ja tõhus keelevorm. Kuni JavaSDK versioonini 5 oli for-lausel ainult üks traditsiooniline vorm. Pärast seda ilmus uus - foreach. See jaotis keskendub operaatori traditsioonilisele vormile. Java for-silmus näeb välja selline:

jaoks (inti=0; i<10; i++) {//Loop statements to be executed

Enne kontrolli ülekandmist tsükli lõpus olevale koodile initsialiseeritakse muutuja i, mis toimib loendurina. Järgmisena peate kontrollima tingimusavaldist, milles loendurit konkreetse väärtusega võrreldi. Kui programm tagastab väärtuse true, käivitatakse tsükli keha. Sel juhul muutub loenduri väärtus etteantud sammu võrra ja tingimusavaldist kontrollitakse uuesti. See juhtub seni, kuni seisund muutub valeks. Parema mõistmise huvides on siin näide Java for loop toimimisest.

avalik klass ForLoops (

avalik static void main (String args) (

kavatseb_väärtus =11;

jaoks )