Scarica Strutture iterative in Java e più Schemi e mappe concettuali in PDF di Programmazione Java solo su Docsity!
Fondamenti di Programmazione in Java
Struttura 3: Iterazione
Questo documento illustra i costrutti iterativi disponibili nel linguaggio Java: while
(precondizionale), do-while (postcondizionale) e for (con contatore). Vengono inoltre trattate le
equivalenze tra i costrutti e le istruzioni di salto break , continue e return.
Argomenti trattati
- Introduzione alle strutture iterative
- Il costrutto iterativo precondizionale (while)
- Il costrutto iterativo postcondizionale (do-while)
- Confronto tra while e do-while
- Il costrutto iterativo con contatore (for)
- Equivalenze tra i costrutti iterativi
- Le istruzioni di salto (break, continue, return)
1. Introduzione alle strutture iterative
Le strutture di controllo iterative permettono di specificare che un dato blocco di istruzioni venga
eseguito ripetutamente, fintanto che determinate condizioni di permanenza nel ciclo siano
soddisfatte. Questo tipo di struttura è fondamentale per scrivere algoritmi reali e non banali.
Per il Teorema di Böhm-Jacopini , un linguaggio che ammette unicamente strutture sequenziali
e condizionali ha un potere espressivo limitato: non è in grado di descrivere algoritmi che
richiedono un numero arbitrario di ripetizioni. Ad esempio, calcolare basen^ con un semplice
if-else richiederebbe un numero infinito di rami, uno per ogni possibile valore dell'esponente.
Java mette a disposizione tre costrutti iterativi, ciascuno adatto a situazioni diverse:
Costrutto Nome comune Caratteristica principale while Precondizionale Controlla la condizione PRIMA di eseguire il blocco do-while Postcondizionale Controlla la condizione DOPO aver eseguito il blocco (almeno 1 iterazione garan for Con contatore Ideale quando il numero di iterazioni è noto a priori
numero = scanner.nextInt(); somma += numero; } System.out.println("La Somma dei numeri inseriti e': " + somma);
2.4 Ciclo infinito
Il caso limite del ciclo infinito si ottiene usando una condizione sempre vera. Nella pratica, si
esce poi dal ciclo con un'istruzione break (vedi sezione 7):
while (true) System.out.println("ciclo while infinito");
Un ciclo infinito involontario si verifica quando il corpo del ciclo non modifica mai le variabili della
condizione. Questo è un errore logico (bug) da evitare sempre.
3. Il costrutto iterativo postcondizionale (do-while)
Il costrutto do-while realizza un ciclo in cui la condizione viene verificata dopo l'esecuzione del
corpo. Ciò garantisce che il blocco di istruzioni venga eseguito almeno una volta ,
indipendentemente dalla condizione.
Sintassi Java:
do {
} while (condizione); // notare il punto e virgola finale!
Pseudocodifica equivalente:
RIPETI
istruzione/i FINCHE' (condizione)
3.1 Caso d'uso tipico – validazione dell'input
Il do-while è particolarmente indicato per i cicli di validazione dell'input: occorre sempre chiedere
almeno una volta il dato all'utente.
int numero; do { System.out.println("Rimani nel ciclo finche' inserisci un numero tra 50 e 100"); numero = scanner.nextInt(); } while (numero >= 50 && numero <= 100); // il ciclo CONTINUA finché il numero è nell'intervallo [50,100] // termina quando viene inserito un numero fuori range
3.2 Esempio applicativo – somma di numeri fino a 0 (versione do-while)
int numero; int somma = 0;
do { System.out.println("Inserire un numero intero [0 per terminare]"); numero = scanner.nextInt(); somma += numero; } while (numero != 0);
System.out.println("La Somma dei numeri inseriti e': " + somma);
Rispetto alla versione con while , il codice è più compatto: non è necessario leggere il primo
numero prima del ciclo perché il blocco viene sempre eseguito almeno una volta.
5. Il costrutto iterativo con contatore (for)
Il costrutto for è ideale quando il numero di ripetizioni è noto a priori. Permette di raggruppare in
un'unica riga l'inizializzazione del contatore, la condizione di permanenza e l'aggiornamento del
contatore.
Sintassi Java:
for (; ; ) {
}
Le tre sezioni della testata del for:
Sezione Descrizione Quando viene eseguita Inizializzazione Inizializza la variabile contatore Una sola volta, all'inizio del ciclo Test Condizione di permanenza nel ciclo; il blocco si esegue solo se veraPrima di ogni iterazione (se falsa subito, corpo mai eseg Incremento Aggiorna il contatore (o altra variabile) Al termine di ogni iterazione, prima di rivalutare il Test
5.1 Esempio 1 – conteggio crescente da 1 a 10
System.out.println("Programma che conta fino a 10"); for (int i = 1; i <= 10; i++) { System.out.println("Numero corrente: " + i); } System.out.println("Fine Programma"); // i parte da 1, sale fino a 10 (incluso), si incrementa di 1 a ogni passo
5.2 Esempio 2 – conteggio decrescente da n a 0
System.out.println("Programma che conta n fino a 0"); System.out.println("Inserire il valore di n"); int n = scanner.nextInt();
for (int i = n; i >= 0; i--) { System.out.println("Numero corrente: " + i); } System.out.println("Fine Programma");
5.3 Versatilità del for – sezioni opzionali
Le tre sezioni di controllo del for sono tutte opzionali. La loro omissione produce comportamenti
diversi:
int n = 10; int i = 1;
// (A) Tutte le sezioni presenti – forma classica for (int i = 1; i <= n; i++) { System.out.println(i); }
// (B) Incremento spostato nel corpo
for (; i <= n; ) { System.out.println(i++); }
// (C) Inizializzazione fuori, incremento nel corpo for (i=1; i <= n; ) { System.out.println(i++); }
// (D) Test sempre vero -> ciclo infinito for (i=1; true; ) { System.out.println(i++); }
// (E) Tutte omesse -> ciclo infinito (equivalente a while(true)) for ( ; ; ) { System.out.println(i++); }
5.4 Più variabili di controllo con l'operatore virgola
Il for consente di inizializzare e aggiornare più variabili contemporaneamente separandole con la
virgola:
// Stampa i numeri da 1 a 10 e contemporaneamente da 10 a 1 int n = 10; int i, j; for (i=1, j=n; i<=n && j>=0; i++, j--) { System.out.println("i: " + i + " ------- j: " + j); } // i e j vengono inizializzati a 1 e 10 simultaneamente // il ciclo prosegue finché ENTRAMBE le condizioni sono vere // a ogni passo i cresce e j decresce di 1
// WHILE
while () { istruzioni; }
// EQUIVALENTE DO-WHILE if () { do { istruzioni; } while (); }
6.5 Da do-while a for
// DO-WHILE do { istruzioni; } while ();
// EQUIVALENTE FOR istruzioni; // esecuzione iniziale garantita for (; ; ) { istruzioni; }
6.6 Da do-while a while
// DO-WHILE do { istruzioni; } while ();
// EQUIVALENTE WHILE istruzioni; // esecuzione iniziale garantita while () { istruzioni; }
7. Le istruzioni di salto
Le istruzioni di salto permettono di alterare il normale flusso di esecuzione di un ciclo o di un
metodo. Le tre principali sono break , continue e return.
Istruzione Effetto Dove si usa break Forza l'uscita immediata dal ciclo (o dallo switch) più internoCicli while, do-while, for; costrutto switch continue Salta il resto del corpo corrente e riprende con l'iterazione successiva (nel for esegue prima l'incremento)Solo in cicli while, do-while, for return Termina l'esecuzione del metodo corrente e restituisce il controllo al chiamanteQualsiasi punto all'interno di un metodo
7.1 break – uscita forzata dal ciclo
L'istruzione break interrompe immediatamente il ciclo o lo switch in cui è contenuta. In cicli
annidati, esce solo dal ciclo più interno.
// Leggi interi fin quando non viene digitato 0 Scanner scanner = new Scanner(System.in); do { System.out.println("Inserisci un numero intero [0 per terminare]"); int numero = scanner.nextInt(); if (numero == 0) { break; // esce immediatamente dal do-while } } while (true); System.out.println("Fine");
Nei cicli annidati il break esce solo dal ciclo più interno. Per uscire da cicli esterni è necessario
usare variabili flag o ristrutturare il codice.
// Stampa n righe di m numeri (usa break per terminare ogni riga) for (int i = 1; i <= n; i++) { int j = 1; while (true) { if (j > m) { break; } // esce dal while interno System.out.print(j + " - "); j++; } System.out.println(); // va a capo }
Attenzione: break NON può essere usato all'interno di un costrutto if che non sia annidato in un
ciclo o in uno switch. Farlo produce un errore di compilazione.
7.2 continue – salto alla prossima iterazione
L'istruzione continue salta il resto del corpo del ciclo corrente e prosegue con l'iterazione
successiva. Nel ciclo for , viene prima eseguito l'incremento e poi rivalutato il test.
// Stampa solo i numeri dispari da 1 a 101 for (int i = 1; i <= 101; i++) { if (i % 2 == 0) { continue; // salta la println per i pari; torna all'incremento i++
8. Riepilogo comparativo
Costrutto Sintassi essenziale Corpo eseguito se... Uso tipico while while (cond) { ... } cond è vera all'ingresso (0+ volte)Numero iterazioni non noto; condizione può essere fals do-while do { ... } while (cond); Sempre almeno 1 volta; poi se cond è veraValidazione input; cicli che devono eseguire almeno un for for (init; test; incr) { ... } test è vero (0+ volte); init e incr gestiti automaticamenteNumero iterazioni noto; contatori; scansione di range
I tre costrutti iterativi, insieme alle strutture di sequenza e selezione, formano un insieme
completo con cui è possibile descrivere qualsiasi algoritmo computabile. La scelta del costrutto
più appropriato per ogni situazione rende il codice più chiaro, leggibile e manutenibile.
