Infinit pentru (Java) buclă

În Java, la fel ca în aproape orice limbaj de programare, există instrumente pentru a oferi mai multe repetarea unui anumit fragment de cod, sau, așa cum sunt numite, cicluri. Ciclurile din Java sunt reprezentate de operatori, cum ar fi pentru și în timp, precum și de soiurile lor. De regulă, ciclurile sunt folosite pentru a trece prin matrice unidimensionale și multidimensionale și structuri de date iterate (inclusiv colecții) pentru a găsi anumite elemente și operații ulterioare cu ele. Cu toate acestea, aceasta nu este singura modalitate de a utiliza un instrument precum bucla Java. Exemple de utilizare vor fi date pe măsură ce acestea sunt luate în considerare.

Ciclul în timp Java: descriere și exemple

Instrucțiunea ciclului de bază din Java este în timp. Fragmentul de cod închis în corpul său va fi repetat până când starea expresiei va fi inclusă în paranteze, după ce va satisface valoarea logică a adevărului. Forma generală a declarației este:

în timp ce (condiție) {

// corpul bucla

}

De îndată ce valoarea condiției logice încetează să mai fie adevărată, codul inclus în corpul bucla va înceta să se execute, iar controlul va fi transferat la linia imediat următoare. Dacă există un singur operator în corpul ciclului, elementele de fixare nu pot fi setate, însă sunt considerate o formă bună dacă stau întotdeauna. Figura de mai sus prezintă o diagramă bloc a funcționării acestui operator.

Pentru claritate, să aruncăm o privire la exemplul din figura de mai jos:

Numărătoarea variabilă declarată are inițial o valoare de 1. Apoi, vom vedea o expresie logică închisă în paranteze după numele operatorului. Va fi adevărat, adică returnează valoarea reală, atâta timp cât valoarea variabilei count este mai mică sau egală cu 10. În bucla cu fiecare trecere (iterație) valoarea variabilă este incrementat cu 1 și afișate pe ecranul consolei. Rețineți că atunci când valoarea variabilei a ajuns la 11, ciclul a încetat să mai funcționeze.

Dacă valoarea contorului de variabilă a fost inițial egală cu 11, atunci condiția de buclă ar fi falsă, iar programul nu va merge nici măcar în corpul său.

Este de remarcat faptul că sintaxa Java vă permite să utilizați instrucțiunea while fără corp. Să dăm un exemplu. Să presupunem că avem două variabile i = 100 și j = 200, ne confruntăm cu sarcina de a software-ului pentru a calcula media lor - puteți folosi „gol în timp ce»:

în timp ce (++ i < --j);

Ca rezultat, valoarea uneia dintre cele două variabile va fi egală cu media valorilor inițiale. După cum puteți vedea, ciclul a funcționat perfect fără un corp și a efectuat toate acțiunile necesare într-o expresie condiționată.

Curățați-vă

În exemplele anterioare, în cazul în care expresia condiționată a revenit inițial la falsă, execuția programului va ignora corpul bucla și va merge mai departe. Cu toate acestea, există adesea situații în care executarea codului conținut în corpul bucla, în mod necesar cel puțin o dată, indiferent de valabilitatea expresiei condiționate. Cu alte cuvinte, se întâmplă că nu este necesar să verificăm valabilitatea unei expresii condiționate la început, dar la sfârșitul unui ciclu. Această funcționalitate poate fi furnizată de un fel de buclă în timp ce se numește do-while. Are următoarea formă:

nu {
// corpul bucla

} în timp ce (condiție);

După cum vedem, corpul buclei este executat mai întâi, și numai atunci este adevărul condiției verificate - și așa mai departe fiecare iterație.

Codul de mai sus va funcționa în același mod ca și în cazul obișnuit. Cu toate acestea, dacă am dat variabila de numărare a unei valori de 11, corpul bucla ar fi executat încă o dată înainte ca operatorul să poată verifica validitatea expresiei.

Descriere și exemple pentru - ciclul Java

Bucla pentru este o formă de limbă universală și eficientă în Java. Înainte de cea de-a cincea versiune a SDK-ului Java, a existat o singură formă tradițională a instrucțiunii pentru, și apoi una nouă pentru fiecare. În această secțiune vom cunoaște forma tradițională a operatorului. pentru Java, bucla arată astfel:

Înainte ca controlul să fie transmis codului în corpul bucla, inițializarea variabilei i care servește ca numărător este efectuată mai întâi. Apoi, verificăm expresia condiționată în care contorul este comparat cu o anumită valoare și dacă se întoarce adevărat, corpul buclă este executat. Apoi, valoarea contorului se modifică la o etapă predeterminată, iar expresia condițională este verificată din nou și așa mai departe până când condiția devine falsă. Diagrama de mai jos ilustrează toate fazele ciclului.

Pentru o înțelegere mai bună, să arătăm cum funcționează buclă Java:

Vedem că variabila loopVal este folosită ca numărător. După fiecare repetare a buclă, valoarea sa va crește cu 1 și aceasta va avea loc până când ajunge la 11. Observați că variabila de control poate fi de asemenea declarată în afara instrucțiunii for, dar dacă nu veți folosi această variabilă oriunde, cu excepția într-o buclă, se recomandă să o declarați direct în declarație. Rețineți că variabila declarată în instrucțiunea însăși are un domeniu de aplicare în cadrul aceleiași buclă.

Există situații în care doriți să declarați mai multe variabile de control al buclă. Pentru Java, o buclă vă permite să specificați două sau mai multe variabile separate printr-o virgulă și faceți acest lucru atât în ​​timpul inițializării, cât și în timpul iterației. Un astfel de operator va avea următoarea formă:

pentru (int i = 1, int j = 10-i < j- ++ i, - j) {}

La fiecare iterație, valoarea variabilei i este incrementată cu 1 și valoarea j variabilă este decrementat cu 1. iterații va fi executată atâta timp cât i este mai mare sau egal cu j.

Caracteristicile utilizării instrucțiunii pentru

Ciclul pentru este o construcție destul de flexibilă, deoarece toate cele trei părți (inițializare, condiție și incrementare / decrementare) nu pot fi utilizate în scopul propus. De exemplu, în loc de o expresie condiționată cu o variabilă de control, puteți înlocui orice variabilă logică.

boolean exit = false;

pentru (int i = 0-! exit- ++ i) {

ieșire = adevărat;

}

În exemplul de mai sus, putem observa modul în care funcționarea buclă este absolut independentă de variabila de control i și numărul de iterații depinde numai de momentul în care variabila de ieșire va fi adevărată. Mai mult decât atât, variabila de control poate fi complet eliminată din bucla și acest lucru nu afectează funcționarea ei: pentru (-! Exit-) {}. Deși acest lucru nu este cel mai rezonabil mod de programare, uneori poate fi util. Principalul lucru este de a oferi o situație în care variabila ia valoarea necesară pentru a ieși din bucla, astfel încât să nu o transforme într-o valoare infinită.

Pentru Java, o buclă poate fi declarată astfel: pentru (- -) {}. Acesta este un exemplu tipic pentru o buclă infinită cu condiții speciale de întrerupere. Despre cum să întrerupem astfel de cicluri, vom vorbi puțin mai târziu.

Ciclu în stil pentru fiecare

Buclele Java foreach sunt folosite întotdeauna pentru enumerarea secvențială a elementelor de matrice sau a unor elemente structuri de date și efectuând anumite operații repetate asupra lor. Un exemplu de această formă a instrucțiunii pentru este prezentat mai jos:

Ca variabilă iterativă, numele este declarat, iar matricea de nume declarată anterior este al doilea argument al operatorului. Numele variabilei va lua valorile fiecărui element al matricei la un moment dat până când toate elementele sale vor fi extrase. Trebuie remarcat faptul că tipul de variabilă trebuie să fie compatibil cu tipul de elemente stocate în matrice. De asemenea, variabila nume este numai pentru citire și încercarea de ao schimba nu va schimba elementul în sine.

Operatori de întrerupere a ciclului

Există trei declarații de întrerupere pentru buclă: pauză, întoarcere și continuă. Primele două sunt capabile să întrerupă complet bucla și continuă să întrerupă numai funcționarea iterației curente. Dacă în codul dvs. utilizați un ciclu Java în mod deliberat infinit, acești operatori trebuie să fie prezenți în el. Luați în considerare un exemplu simplu de utilizare a pauzei:

Deși 11 iterații sunt furnizate în această instrucțiune, numai 8 vor fi executate, pentru că atunci când contorul i este 7, condiția în corpul căreia există o declarație de pauză va funcționa.

Instrucțiunea de returnare acționează într-un mod similar, cu diferența că nu oferă doar o ieșire din buclă Java, ci și metoda în care este plasată această bucla.

Folosiți pauza ca trebuie

Trebuie avut în vedere faptul că pauza întrerupe activitatea doar acelui ciclu în corpul din care este situat direct, adică Dacă îl folosiți într-o buclă imbricată, bucla exterioară nu va înceta să funcționeze. Pentru aceasta, declarația de pauză poate fi folosită ca o formă civilizată de geto.

În această versiune, acest operator este utilizat împreună cu eticheta, care vă permite să organizați ieșirea nu numai din cicluri, ci din orice bloc de cod. O etichetă este un identificator numit în mod corespunzător cu un colon după ea. Eticheta este declarată la începutul blocului marcat de cod. Pentru a întrerupe executarea unui bloc marcat, în locul potrivit, trebuie să declarați: break name_name. Luați în considerare exemplul din figura de mai jos:

Codul declară trei blocuri cu numele etichetelor Un, Două și Trei, respectiv. Instrucțiunea de rupere cu eticheta Two este imbricată în toate cele trei blocuri, dar când este declanșată, programul va ieși din blocurile Trei și Două și va continua execuția în blocul One. Ie în consola vom vedea două mesaje: Trei și Unu.

concluzie

Am aflat despre conceptul de bucle în Java, principalele timpuri și pentru declarații, și modul lor de a face și, respectiv, pentru fiecare formă, respectiv. Pentru o înțelegere mai bună, vă recomandăm să faceți exerciții folosind acești operatori în diferite forme, precum și diferite modalități de a le întrerupe și de a vă deplasa de la un bloc la altul.