In questo tutorial impareremo come rieseguire parti del nostro codice in modo controllato osservando i diversi tipi di loop in Giava... Diamo un'occhiata più da vicino ai loop: mentre, fare-mentre, per... Cercheremo di determinare in quali casi, quale dei cicli è più adatto per l'uso.
Quindi daremo una rapida occhiata al tema dei numeri casuali ( a casonumeri). Guardiamo Giava-Classe A caso e come può aiutarci nel nostro gioco.
Un ciclo, come suggerisce il nome, è un modo per eseguire lo stesso pezzo di codice tutte le volte necessarie (mentre il risultato dell'esecuzione del codice in un ciclo non si ripeterà necessariamente). Il numero di ripetizioni dell'esecuzione del ciclo può essere definito in anticipo o sconosciuto al programmatore stesso. Vedremo le principali tipologie di loop che il linguaggio ci suggerisce di utilizzare. Giava. E poi ne introdurremo alcuni nel nostro gioco, migliorandolo così.
Mentre il ciclo
Ciclo mentre ha la sintassi più semplice. Ricorda Se-istruzione che abbiamo studiato un po 'prima. All'espressione condizionale dell'operatore Se(cosa c'è tra parentesi dopo la parola Se) puoi inserire quasi tutte le combinazioni di operatori e variabili. Se l'espressione è vera ( vero), quindi il codice racchiuso nel corpo del blocco Se verrà eseguito. Allo stesso modo in un ciclo mentre mettiamo un'espressione che può valutare a vero o falso come mostrato in questo codice:
Int x = 10; while (x> 0) (x--; // x diminuisce di uno ad ogni passaggio del ciclo)
Cosa sta succedendo qui? La prima cosa fuori dal giro mentre abbiamo dichiarato una variabile X genere int e ha assegnato il valore “10” a questa variabile. Poi inizia il ciclo mentre, nelle condizioni in cui è scritto “ x> 0 "- questo significa che il codice scritto nel corpo del ciclo mentre verrà eseguito finché la variabile X Di più 0 e la condizione non raggiungerà il valore falso... Pertanto, il codice verrà eseguito 10 volte (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; x = 3, x> 0; x = 2, x> 0; x = 1, x> 0). Nel primo passaggio del ciclo x = 10, nel secondo già 9 , nel terzo 8 eccetera. E quando X sarà uguale 0 , allora la condizione per entrare nel ciclo non sarà soddisfatta e il programma continuerà dalla riga successiva dopo la fine del ciclo.
Proprio come nell'operatore Se, è possibile una situazione in cui il ciclo non verrà eseguito nemmeno una volta. Dai un'occhiata al seguente esempio:
Int x = 10; while (x> 10) (// del codice // ma non verrà mai eseguito finché x non è maggiore di 10)
Inoltre, non ci sono restrizioni sulla complessità dell'espressione della condizione o sulla quantità di codice che può essere scritta nel corpo del ciclo:
Int playerLives = 3; int navi aliene = 10; while (playerLives> 0 && alienShips> 0) (// Tutto il codice del gioco è qui // ... // ... // ecc.) // il programma continuerà qui quando playerLives o alienShips = 0
Questo ciclo verrà eseguito fino a quando la variabile giocatore vive o navi aliene non sarà uguale o minore di zero. Non appena una di queste condizioni è soddisfatta, l'espressione nella condizione assumerà il valore falso e il programma continuerà sulla riga successiva al termine del ciclo.
Va notato che non appena il programma entra nel corpo del ciclo, verrà eseguito anche se la condizione del ciclo diventa falso, da qualche parte nel corpo del ciclo, perché la condizione viene verificata solo in entrata:
Int x = 1; while (x> 0) (x--; // x ora è 0 e la prossima volta la condizione sarà falsa // Ma questa riga verrà eseguita // E questa // E anche questa)
Nell'esempio sopra, il corpo del ciclo verrà eseguito una volta. Inoltre, puoi impostare una condizione tale che il ciclo verrà eseguito per sempre - questo si chiama ciclo infinito. Ecco un esempio:
Int x = 0; while (true) (x ++; // Diventerò davvero grande!)
Esci dal loro ciclo. Parola chiave rottura
E se avessimo davvero bisogno di usare un ciclo infinito, ma in modo da poter decidere a che punto uscirne. A questo scopo in Giava c'è una parola chiave rottura... Possiamo usare rottura quando dobbiamo "uscire" dal ciclo:
Int x = 0; while (true) (x ++; // diventerò davvero grande! break; // No, non lo farai! // il codice qui non sarà raggiunto)
Probabilmente hai già intuito che è possibile combinare diversi strumenti decisionali, come ad esempio Se,altro,interruttore dentro il nostro ciclo mentre e altri loop, che considereremo di seguito. Per esempio:
Int x = 0; int tooBig = 10; while (true) (x ++; // diventerò molto grande! if (x == tooBig) (break; // No, non lo farai.) // il codice sarà disponibile qui fino a quando x è 10)
Puoi scrivere molte più varianti diverse, ma l'applicazione pratica di questa conoscenza è più importante per noi, quindi non andremo in profondità ora. Diamo un'occhiata a un altro concetto che può essere utilizzato in un ciclo.
Parola chiave Continua
Continua agisce quasi come rottura... Parola chiave Continua ti butterà fuori dal corpo del ciclo, ma poi controllerà l'espressione condizionale piuttosto che continuare dopo la parentesi graffa chiusa del ciclo, come nel caso di rottura... L'esempio seguente mostra l'uso di Continua:
Int x = 0; int tooBig = 10; int tooBigToPrint = 5; while (true) (x ++; // Diventerò molto grande! if (x == tooBig) (break;) // No, non lo farai. // Il codice qui sarà disponibile solo fino a quando x sarà 10 if (x> = tooBigToPrint) (// non verrà più stampato sullo schermo, ma il ciclo continuerà;) // il codice qui sarà disponibile fino a quando x è uguale a 5 // codice per stampare x sullo schermo)
Spiegazione: dichiariamo e inizializziamo le variabili. Entriamo nel ciclo - aggiungiamo al valore della variabile X unità (ora X= 1). Selezionando "1 è 10?" - falso- primo operatore Se non eseguito. Il controllo successivo è "1 è maggiore o uguale a 5?" - falso- secondo operatore Se non eseguito. deduciamo X sullo schermo.
Considera l'opzione quando X assumerà il valore 5 entrando nel ciclo. Entriamo nel ciclo - aggiungiamo al valore della variabile X unità (ora X= 6). Selezionando "6 fa 10?" - falso- primo operatore Se non eseguito. Il controllo successivo è "6 è maggiore o uguale a 5?" - vero- entriamo nel corpo Se — Continua, uscire dal ciclo e verificare la condizione per entrare nel ciclo.
Ora l'opzione è quando X assumerà il valore 9 entrando nel ciclo. Entriamo nel ciclo - aggiungiamo al valore della variabile X unità (ora X= 10). Selezionando "10 è uguale a 10?" - vero- entriamo nel corpo Se — rottura, esci dal ciclo e il codice continuerà dietro la parentesi graffa di chiusura del ciclo mentre.
Ciclo "fai-mentre"
Quasi uguale al ciclo precedente, con l'eccezione di una particolarità: il controllo per l'esecuzione dell'espressione condizionale avverrà dopo il corpo del ciclo. Ciò significa che il ciclo fare-mentre verrà sempre eseguito almeno una volta. Dai un'occhiata a un esempio:
Int x = 0; do (x ++;) mentre (x< 10); //x теперь = 10
parole chiave rottura,Continua
Per il ciclo
Ciclo per ha una sintassi più complessa di mentre e fare-mentre poiché ci vuole un po' più di manipolazione per inizializzarlo. Esaminiamolo prima e poi scomponiamolo in parti:
Per (int i = 0; i< 10; i++){ //Что-то, что должно произойти 10 раз будет записано здесь }
Come la vede il compilatore? Come questo:
For (dichiarazione e inizializzazione; condizione; cambio dopo ogni ciclo) (// corpo del ciclo)
- Dichiarazione e inizializzazione- abbiamo creato una nuova variabile di tipo int Con nome io e gli ho assegnato il valore 0 ;
- Condizione- simile ad altri loop considerati in precedenza, qui controlliamo la condizione di entrare nel loop. Se il valore è calcolato come vero, quindi entriamo nel corpo del ciclo;
- Modificare dopo ogni ciclo- nell'esempio sopra io++ significa che dopo il prossimo passaggio del ciclo siamo al valore della variabile io aggiungere uno (1). Inoltre, cambiando la variabile, possiamo scrivere e io— per sottrarre uno, ad esempio:
parole chiave rottura,Continua può essere utilizzato anche in questo ciclo.
Ciclo per prende il controllo dell'inizializzazione, del controllo delle condizioni e della modifica delle variabili. Proviamo questo ciclo in pratica nella nostra applicazione subito dopo aver fatto conoscenza con numeri casuali e metodi.
Ti sei mai chiesto perché esistono i programmi? Se semplifichiamo e generalizziamo la risposta a questa domanda, risulta che i programmi sono necessari per automatizzare il flusso di lavoro, aumentare la velocità del lavoro svolto, liberare una persona da migliaia di azioni monotone e così via. Concentriamoci sulla ripetizione delle azioni una dopo l'altra o, in termini semplici, cicli.
Un ciclo è l'esecuzione sequenziale di azioni ripetitive basate su una data precondizione. Ad esempio, devi riorganizzare cento scatole da un angolo all'altro. Se in qualche modo lo scrivi nel linguaggio Java (purtroppo Java non può riorganizzare le caselle per te), ottieni cento righe:
1. prendi la scatola numero 1 e mettila in un altro angolo;
2. prendi la scatola numero 2 e mettila in un altro angolo;
3. prendi la scatola numero 3 e mettila in un altro angolo;
…
100. prendi la scatola n. 100 e mettila in un altro angolo;
Cento righe di codice sono già tante, ma ce ne sono mille, due, tre e così via. Per questi scopi, vale a dire per semplificare la registrazione di azioni ripetitive, vengono utilizzati dei cicli.
Ci sono tre istruzioni che rappresentano i loop nel linguaggio Java: while, do / white e for. Ciascuno degli operatori è necessario nella propria situazione, ma l'operatore for è ancora utilizzato più spesso. Consideriamo in ordine ciascuno degli operatori.
Mentre dichiarazione
La sintassi per l'istruzione while è la seguente:
Mentre (condizione) (// azioni)
Avviene anche il soddisfacimento di una certa precondizione, ma a differenza dell'operatore if / else, questa costruzione è costruita su cicli di controllo delle condizioni. Quando il programma raggiunge l'istruzione while, se la condizione proposta è vera, vengono eseguite tutte le azioni nel blocco di parentesi graffe (...). Dopo aver completato queste azioni, il programma esegue nuovamente un altro controllo della condizione dopo l'istruzione while e, se la condizione è nuovamente vera, le azioni nel blocco vengono ripetute. Le azioni nel blocco vengono eseguite fino a quando la condizione diventa falsa e solo allora il ciclo while termina.
Per uscire dai loop, vengono spesso utilizzati i cosiddetti contatori. Considera un piccolo esempio:
Int i = 0; mentre io< 10) { // действия i++; }
Innanzitutto, alla variabile i viene assegnato il valore 0, quindi viene verificata la condizione i0)
(// azioni i--;)
Le stesse azioni, ma nella direzione opposta. Inoltre, nel ciclo while (e in effetti in altri cicli) è possibile utilizzare variabili booleane contenenti valori falsi o veri. In questo caso, viene verificata una determinata precondizione.
booleano i = vero; mentre (i) (// azioni)
La variabile i è vera, viene assegnato il valore vero, quindi il ciclo while viene eseguito finché alla variabile i viene assegnato il valore falso. Pertanto, è necessario occuparsi di uscire da un tale ciclo, altrimenti il ciclo while verrà eseguito indefinitamente e tali cicli vengono chiamati cicli infiniti.
Infine, vorrei attirare la vostra attenzione sull'operatore uguale ==. Se scrivi il ciclo in questo modo:
Int i = 0 while (i == 5) (// azioni i ++;)
Questo risulterà essere un ciclo completamente funzionante, ma se commetti un errore o per abitudine usi la versione classica dell'operatore uguale a =, usato in matematica, allora avrai un problema sotto forma di un ciclo infinito.
Int i = 0 while (i = 5) (// azioni i ++;)
Nella precondizione, alla variabile i viene assegnato il valore 5, ma questa azione non è vietata e con cosa si finisce? L'esecuzione di questo blocco del ciclo inizierà alla fine del quale il valore di i aumenterà di uno, ma nella precondizione dopo l'istruzione while, alla variabile i verrà assegnato nuovamente il valore cinque e il ciclo continuerà il suo lavoro indefinitamente. Questo è un esempio di un semplice ciclo infinito e, di conseguenza, un classico errore che accade molto spesso con i programmatori alle prime armi.
Fai / mentre loop
Il ciclo while appena considerato da noi, in determinate condizioni, potrebbe non funzionare. Ad esempio, se la condizione è inizialmente falsa, il ciclo non verrà mai eseguito. Il programma, una volta raggiunta la riga di codice con l'istruzione while, verificherà la condizione e, se è falsa, ignorerà l'intero ciclo e andrà al codice immediatamente successivo al ciclo while. Ma a volte diventa necessario eseguire il ciclo almeno una volta. Per questi scopi, Java ha un ciclo do / while. Il ciclo do / while viene scritto e creato come segue:
Esegui (// azioni) mentre (condizione)
C'è un corpo del ciclo tra le istruzioni do e while, che verrà eseguito fino a quando la postcondizione che segue l'istruzione while è falsa. Il corpo del ciclo verrà eseguito almeno una volta, dopodiché verrà verificata la condizione. Il ciclo do/while non viene utilizzato spesso, ma a volte si rivela indispensabile.
Per il ciclo
Questo è il ciclo più comune nella programmazione. Il ciclo for si basa sulla manipolazione del contatore. Il significato di questo ciclo è simile ai cicli while e do / while discussi sopra. Guarda come appare la sintassi per un ciclo for:
Per (int i = 0; i< 10; i++) { // действие }
La parola chiave for è seguita da una condizione per l'esecuzione del ciclo. La condizione stessa combina tre fasi. Segue prima l'inizializzazione del contatore i = 0, poi il controllo della condizione i< 10 и в конце увеличение переменной i на единицу.
Il ciclo for funziona come segue. Quando il programma raggiunge il ciclo, viene inizializzato il contatore i = 0 e viene verificata la condizione i< 10. Далее программа переходит в тело цикла. По окончанию всех действий в цикле for, происходит обращение к третьему этапу цикла: i++, увеличивая счетчик на единицу. После чего сразу же происходит переход ко второму этапу – проверке переменной i < 10 и повторный выход в тело цикла. Весь цикл продолжается до тех пор, пока условие i < 10 не станет ложным. Цикл for используется постоянно при инициализации массива данных, где без него очень сложно, а порой и не возможно обойтись. Так же как и в цикле while возможно использование оператора декремента, например.
In Java, come in quasi tutti i linguaggi di programmazione, esistono strumenti per fornire ripetizioni multiple di un determinato pezzo di codice o, come vengono chiamati, loop. I loop in Java sono rappresentati da istruzioni come for e while e le loro varianti. Di norma, i cicli vengono utilizzati per iterare su array unidimensionali e multidimensionali e strutture di dati iterabili (comprese le raccolte) al fine di trovare elementi specifici e ulteriori operazioni con essi. Tuttavia, questo non è l'unico modo per utilizzare uno strumento come Java Loop. I casi d'uso verranno forniti man mano che vengono presi in considerazione.
Java: descrizione ed esempi
L'operatore di ciclo fondamentale in Java è while. Il frammento di codice racchiuso nel suo corpo verrà ripetuto finché la condizione dell'espressione racchiusa tra parentesi dopo soddisfa il valore logico di verità. La forma generale dell'istruzione while è la seguente:
mentre (condizione) (
// corpo del ciclo
Non appena il valore della condizione logica cessa di essere vero, il codice racchiuso nel corpo del ciclo cesserà di essere eseguito e il controllo verrà trasferito alla riga immediatamente successiva.
Se c'è un solo operatore nel corpo del ciclo, allora le parentesi graffe possono essere omesse, ma è considerata una buona forma se compaiono sempre. La figura sopra mostra uno schema a blocchi del funzionamento di questo operatore.
Per chiarezza, diamo un'occhiata all'esempio mostrato nella figura seguente:
La variabile dichiarata count ha inizialmente il valore 1. Successivamente, vediamo un'espressione booleana racchiusa tra parentesi dopo il nome dell'operatore. Sarà vero, cioè restituisce true fintanto che il valore della variabile count è minore o uguale a 10. Nel corpo del ciclo, ad ogni passaggio (iterazione), il valore della variabile viene aumentato di 1 e visualizzato sullo schermo della console. Nota che quando la variabile ha raggiunto 11, il ciclo ha smesso di funzionare.
Se il valore della variabile count fosse inizialmente uguale a 11, allora la condizione del ciclo sarebbe falsa e il programma non entrerebbe nemmeno nel suo corpo.
Vale la pena notare che la sintassi Java consente di utilizzare un'istruzione while senza corpo. Facciamo un esempio. Supponiamo di avere due variabili i = 100 e j = 200, ci troviamo di fronte al compito di calcolare la loro media aritmetica a livello di codice - per questo puoi usare il "vuoto" mentre:
mentre (++ i< --j);
Di conseguenza, il valore di una delle due variabili sarà uguale alla media dei loro valori originali. Come puoi vedere, il ciclo ha funzionato bene senza un corpo e ha eseguito tutte le azioni necessarie in un'espressione condizionale.
Ciclo "fai-mentre"
Negli esempi precedenti, se l'espressione condizionale inizialmente restituiva false, l'esecuzione del programma ignorerebbe il corpo del ciclo e andrebbe avanti. Tuttavia, spesso si verificano situazioni in cui l'esecuzione del codice contenuto nel corpo del ciclo è obbligatoria almeno una volta, indipendentemente dalla verità dell'espressione condizionale. In altre parole, succede che è necessario verificare la verità di un'espressione condizionale non all'inizio, ma alla fine del ciclo. Una variazione del ciclo while chiamata do-while può fornire questa funzionalità. Ha la seguente forma:
fare (
// corpo del ciclo
) mentre (condizione);
Come possiamo vedere, prima il corpo del ciclo va in esecuzione, e solo allora viene verificata la verità della condizione - e così via ad ogni iterazione.
Il codice sopra funzionerà più o meno allo stesso modo di un normale while. Tuttavia, se avessimo assegnato il valore 11 alla variabile count, il corpo del ciclo verrebbe comunque eseguito una volta prima che l'operatore possa verificare che l'espressione sia vera.
Descrizione ed esempi per - Ciclo Java
È un modulo di linguaggio versatile ed efficiente in Java. Prima della quinta versione dell'SDK Java, esisteva solo una forma tradizionale dell'istruzione for, quindi ne appariva una nuova, per ciascuna. In questa sezione faremo conoscenza con la forma tradizionale dell'operatore. per Java il ciclo è simile a questo:
Prima che il controllo venga trasferito al codice nel corpo del ciclo, la variabile i viene inizializzata per fungere da contatore. Successivamente, viene verificata un'espressione condizionale, in cui il contatore viene confrontato con un determinato valore e, se restituisce vero, viene eseguito il corpo del ciclo. Quindi il valore del contatore viene modificato di un passo predeterminato e l'espressione condizionale viene nuovamente controllata, e così via finché la condizione diventa falsa. Il diagramma di flusso seguente illustra tutte le fasi del ciclo.
Per una migliore comprensione, ecco un esempio di come funziona il ciclo for Java:
Possiamo vedere che la variabile loopVal viene utilizzata come contatore. Dopo ogni iterazione del ciclo, il suo valore aumenterà di 1 e questo continuerà fino a raggiungere 11. Nota che la variabile di controllo può essere dichiarata al di fuori dell'istruzione for, ma se non utilizzerai questa variabile da nessuna parte tranne che in un loop, si consiglia di dichiararlo direttamente nell'istruzione. Tieni presente che una variabile dichiarata nell'istruzione stessa ha l'ambito all'interno di quel ciclo stesso.
Ci sono situazioni in cui è necessario dichiarare diverse variabili che controllano il ciclo. Per Java, un ciclo permette di specificare due o più variabili separate da virgole, e questo può essere fatto sia durante la loro inizializzazione che durante l'iterazione. Un tale operatore sarà simile a questo:
per (int i = 1, int j = 10; i< j; ++i, --j) {}
Ad ogni iterazione, il valore della variabile i aumenterà di 1 e il valore della variabile j diminuirà di 1. Le iterazioni verranno eseguite finché i non sarà maggiore o uguale a j.
Specifiche dell'utilizzo dell'operatore for
Il ciclo for è abbastanza flessibile perché tutte e tre le sue parti (inizializzazione, condizione e incremento/decremento) possono essere utilizzate off-label. Ad esempio, invece di un'espressione condizionale con una variabile di controllo, è possibile sostituire qualsiasi variabile booleana.
uscita booleana = falso;
for (int i = 0;! exit; ++ i) (
Nell'esempio sopra, possiamo osservare come il lavoro del ciclo sia assolutamente indipendente dalla variabile di controllo i e il numero di iterazioni dipenda unicamente dal momento in cui la variabile exit diventa vera. Inoltre, la variabile di controllo può essere completamente rimossa dal ciclo e ciò non influirà in alcun modo sul suo funzionamento: for (;! Exit;) (). Sebbene non sia il modo più intelligente per programmare, a volte può essere utile. L'importante è prevedere una situazione in cui la variabile assumerà il valore necessario per uscire dal ciclo, in modo da non trasformarlo in uno infinito.
Per Java, un ciclo può essere dichiarato in questo modo: for (;;) (). Questo è un tipico esempio di loop infinito con condizioni di interrupt speciali. Parleremo di come interrompere tali cicli un po 'più tardi.
Per ogni ciclo
Il ciclo foreach di Java viene sempre utilizzato per scorrere gli elementi di un array o qualcosa del genere ed eseguire determinate operazioni ripetitive su di essi. Di seguito è riportato un esempio di questa forma dell'istruzione for:
Il nome viene dichiarato come una variabile di iterazione e l'array di stringhe dei nomi dichiarato in precedenza è il secondo argomento dell'operatore. Il nome della variabile prenderà a turno i valori di ogni elemento dell'array fino a quando tutti i suoi elementi non saranno stati recuperati. Va notato che il tipo della variabile deve essere compatibile con il tipo degli elementi che sono memorizzati nell'array. Inoltre, la variabile name è disponibile esclusivamente per la lettura e un tentativo di modificarla non cambierà l'elemento stesso nell'array.
Operatori di loop di interruzione
Ci sono tre istruzioni di interruzione del ciclo: break, return e continue. I primi due sono in grado di interrompere completamente il lavoro del ciclo, mentre continue interrompe solo il lavoro dell'iterazione corrente. Se usi deliberatamente un ciclo Java infinito nel tuo codice, questi operatori devono essere presenti in esso. Diamo un'occhiata a un semplice esempio di utilizzo di break:
Sebbene questa istruzione for fornisca 11 iterazioni, ne verranno eseguite solo 8, perché quando il contatore i è 7, verrà attivata la condizione, nel cui corpo è presente un'istruzione break.
L'istruzione return funziona in modo simile, con la differenza che non solo esce dal ciclo Java, ma esce anche dal metodo in cui è posizionato il ciclo.
Usando la pausa come goto
Va tenuto presente che l'interruzione interrompe il lavoro solo del ciclo nel corpo di cui si trova direttamente, ad es. se lo usi in un ciclo annidato, il ciclo esterno non smetterà di funzionare. Per questo, l'istruzione break può essere usata come una forma civilizzata di goto.
In questa versione, questo operatore viene utilizzato insieme a un'etichetta, che consente di organizzare un'uscita non solo dai cicli, ma anche da qualsiasi blocco di codice. Un'etichetta è un identificatore con un nome appropriato seguito da due punti. L'etichetta viene dichiarata all'inizio del blocco di codice da contrassegnare. Per interrompere l'esecuzione di un blocco contrassegnato, devi dichiarare nel posto giusto: break tag_name. Considera l'esempio nella figura seguente:
Il codice dichiara tre blocchi con i nomi di etichetta Uno, Due e Tre, rispettivamente. L'istruzione break etichettata Two è nidificata in tutti e tre i blocchi, ma quando viene attivata, il programma uscirà dai blocchi Three e Two e continuerà l'esecuzione nel blocco One. Quelli. vedremo due messaggi nella console: Tre e Uno.
Conclusione
Abbiamo familiarizzato con il concetto di loop in Java, le principali istruzioni while e for, e le loro forme do-while e for each, rispettivamente. Per una migliore comprensione, si consiglia di fare esercizi utilizzando questi operatori in varie forme, nonché vari modi per interromperli e spostarsi da un blocco all'altro.
Ultimo aggiornamento: 31.10.2018
I loop sono un altro tipo di struttura di controllo. I loop consentono, a seconda di determinate condizioni, di eseguire una determinata azione più volte. Il linguaggio Java ha i seguenti tipi di loop:
Per il ciclo
Un ciclo for ha la seguente definizione formale:
For ([inizializzazione contatore]; [condizione]; [modifica contatore]) (// azioni)
Considera uno standard per il ciclo:
Per (int i = 1; i< 9; i++){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); }
La prima parte della dichiarazione del ciclo - int i = 1 crea e inizializza il contatore i. Il contatore non deve essere di tipo int. Può essere qualsiasi altro tipo numerico, ad esempio float. Prima che il ciclo venga eseguito, il contatore sarà 1. In questo caso, equivale a dichiarare una variabile.
La seconda parte è la condizione in base alla quale verrà eseguito il ciclo. In questo caso, il ciclo verrà eseguito fino a quando i raggiunge 9.
E la terza parte sta incrementando il contatore di uno. Ancora una volta, non è necessario incrementare di uno. Può essere ridotto: i--.
Di conseguenza, il blocco del ciclo verrà eseguito 8 volte finché il valore di i diventa uguale a 9. E ogni volta questo valore aumenterà di 1.
Non è necessario specificare tutte le condizioni quando si dichiara un ciclo. Ad esempio, possiamo scrivere così:
Int i = 1; for (;;) (System.out.printf ("Il quadrato di% d è% d \ n", i, i * i);)
La definizione del ciclo rimane la stessa, solo che ora i blocchi nella definizione sono vuoti: for (;;). Ora non esiste una variabile contatore inizializzata, nessuna condizione, quindi il ciclo verrà eseguito per sempre - un ciclo infinito.
In alternativa, puoi omettere un numero di blocchi:
Int i = 1; per (; io<9;){ System.out.printf("Квадрат числа %d равен %d \n", i, i * i); i++; }
Questo esempio è equivalente al primo esempio: abbiamo anche un contatore, solo che è stato creato al di fuori del ciclo. Abbiamo una condizione per l'esecuzione del ciclo. E c'è già un incremento del contatore nel blocco for stesso.
Il ciclo for può definire e manipolare più variabili contemporaneamente:
Int n = 10; per (int i = 0, j = n - 1; i< j; i++, j--){ System.out.println(i * j); }
Fai il ciclo
Il ciclo do esegue prima il codice del ciclo e poi verifica la condizione nell'istruzione while. E finché questa condizione è vera, il ciclo si ripete. Ad esempio:
Intj = 7; do (System.out.println (j); j--;) while (j> 0);
In questo caso, il codice del ciclo verrà eseguito 7 volte finché j non sarà uguale a zero. È importante notare che il ciclo do garantisce almeno un'esecuzione dell'azione, anche se la condizione nell'istruzione while non è vera. Quindi, possiamo scrivere:
Intj = -1; do (System.out.println (j); j--;) while (j> 0);
Sebbene j sia inizialmente minore di 0, il ciclo verrà comunque eseguito una volta.
Mentre il ciclo
Il ciclo while verifica immediatamente la verità di alcune condizioni e, se la condizione è vera, viene eseguito il codice del ciclo:
Intj = 6; while (j> 0) (System.out.println (j); j--;)
Le dichiarazioni continue e break
L'istruzione break ti consente di uscire dal ciclo in qualsiasi momento, anche se il ciclo non ha terminato il suo lavoro:
Ad esempio:
< nums.length; i++){ if (nums[i] >10) pausa; System.out.println (numeri [i]); )
Poiché il ciclo controlla se l'elemento dell'array è maggiore di 10, non vedremo gli ultimi due elementi sulla console, perché quando nums [i] è maggiore di 10 (cioè uguale a 12), verrà attivata l'istruzione break e il ciclo finirà.
È vero, non vedremo nemmeno l'ultimo elemento, che è inferiore a 10. Ora faremo in modo che se il numero è maggiore di 10, il ciclo non termina, ma passa semplicemente all'elemento successivo. Per fare ciò, utilizzare l'operatore continua:
Int nums = nuovo int (1, 2, 3, 4, 12, 9); per (int i = 0; i< nums.length; i++){ if (nums[i] >10) continuare; System.out.println (numeri [i]); )
In questo caso, quando l'esecuzione del ciclo raggiunge il numero 12, che non soddisfa la condizione di test, il programma salterà semplicemente questo numero e passerà all'elemento successivo dell'array.
Un ciclo è un blocco di istruzioni che viene eseguito più e più volte finché viene soddisfatta una determinata condizione. Il pezzo di codice ripetuto è chiamato "corpo del ciclo". Un'esecuzione di un corpo di ciclo è chiamata iterazione.
In Java, puoi lavorare con loop di diversi tipi: per questo ci sono i seguenti operatori:
mentre- ciclo con precondizione- prima controlliamo la condizione, poi eseguiamo il corpo del ciclo;
fare durante- ciclo con postcondizione- prima eseguiamo una volta il corpo del ciclo, poi controlliamo la condizione e, se è soddisfatta, proseguiamo;
per- un ciclo con un contatore - viene eseguito e ad ogni iterazione aggiorna il contatore fintanto che la condizione nella dichiarazione del ciclo è soddisfatta (ovvero il condition check restituisce true);
scorciatoia per(noto come foreach in altre lingue) - itera sull'array dal primo all'ultimo elemento ed esegue il corpo del ciclo ad ogni iterazione.
L'essenza della condizione del ciclo è controllare un'espressione con una o più variabili: “Mentre a<11, в каждой итерации выполняем тело цикла и увеличиваем "а" на 1». Но чему равно «а» при первом выполнении цикла?
Se usiamo i costrutti while, il valore deve essere specificato prima dell'inizio del ciclo:
int a = 1;
mentre (a< 11) {
System.out.println (a);
un ++; // aumenta a di uno
}
Se una variabile funziona come contatore di loop e non viene utilizzata al di fuori di essa, viene inizializzata direttamente nella condizione. E poi scrivono cosa farne alla fine di ogni iterazione. Tutto questo in una riga - utilizzando per:
per (a = 1, a<11, i++) {
System.out.println (a);
}
Otteniamo lo stesso risultato. L'elenco potrebbe essere iniziato da zero o da un valore negativo: definiamo noi stessi l'intervallo.
La scorciatoia per loop non indica il numero di ripetizioni o le azioni alla fine di un passaggio. Un ciclo foreach viene utilizzato per scorrere gli array. Dal primo elemento devi passare al successivo, fino alla fine dell'array.
int ms = (1, 2, 3, 4); // crea un array
int s = 0;
for (int i: ms) (// indica su cosa eseguire l'iterazione
s * = io; //moltiplica gli elementi in sequenza
}
System.out.println (s);
Cicli nidificati Java
I cicli possono essere annidati l'uno nell'altro. In questo caso, viene moltiplicato il numero di ripetizioni dei loop esterni e nidificati. Se l'esterno deve essere eseguito 5 volte e l'interno deve essere eseguito 5 volte, l'intero ciclo verrà eseguito 25 volte.
Mostriamo la tavola pitagorica usando due array:
int a, b, risultato = 0;
per (a = 2; a< 10; a++) {
per (b = 2; b< 10; b++) {
risultato = a * b;
System.out.println (a + "x" + b + "=" + risultato);
}
}
Creazione di oggetti in un ciclo Java
I loop sono utili quando devi creare e numerare molti oggetti. Il loro numero è talvolta sconosciuto in anticipo: gli oggetti possono essere creati su richiesta dell'utente. Quindi abbiamo chiesto quanto serve e abbiamo scritto il numero nella variabile n. Ora creiamo oggetti nella quantità richiesta:
Qualcosa array = nuovo Qualcosa [n]; // crea un array di tipo "qualcosa" da n elementi
per (int i = 0; i< n; i++){
array [i] = nuovo Qualcosa (); // crea "qualcosa" e lo inserisce in un array
}
Come uscire da un ciclo Java
Per uscire dal ciclo ci sono le parole chiave break - "interrupt", continue - "resume" e return - "return". Il comando break fa sì che il programma esegua le istruzioni che seguono il ciclo. Le condizioni di interruzione del ciclo in Java sono formalizzate tramite if-branching. La cosa principale è che il controllo viene eseguito prima del corpo principale del ciclo.
// dopo aver creato l'array m, scrivi:
per (a: m) (
se (a == 5) rompere;
System.out.println (a);
}
Gli operatori di branching e looping in Java spesso lavorano insieme: avviamo un ciclo, e al suo interno controlliamo se è ancora soddisfatta una condizione, in base alla quale è necessario interrompere il ciclo o fare qualcos'altro.
Se usi break in un ciclo annidato, solo questo si interromperà e quello esterno continuerà a essere eseguito.
Per interrompere prematuramente l'iterazione di un ciclo for in Java, utilizzare continue. Quando il programma lo raggiunge, salta la parte non completata dell'iterazione, aggiorna il contatore e procede all'iterazione successiva.
Nei costrutti while, lo stesso continue funziona diversamente: ci riporta a verificare la condizione di continuazione del ciclo. Un altro comando - return - restituisce il programma nel punto in cui è stato chiamato il metodo, in cui si trova il ciclo.
Sia continue che break possono essere usati con un'etichetta - per saltare alla parte desiderata del codice - per analogia con goto:
pausa Mark1; // a condizione che ci sia un Mark1 da qualche parte più in alto:
Ciclo infinito Java
È facile creare un ciclo infinito: devi solo omettere i parametri per:
per (;;) ()
Più è difficile trarne beneficio. Di solito un ciclo infinito è un errore fatale che interferisce con l'esecuzione del programma. Pertanto, ogni ciclo dovrebbe essere controllato per la capacità di essere completato correttamente al momento giusto. Per questo hai bisogno di:
- specificare le condizioni di interruzione nel corpo del ciclo,
- assicurarsi che la variabile nella condizione di interruzione possa assumere un valore al quale il ciclo si arresterà.
