Un approccio a Java: Il ciclo while

Ciao a tutti e bentornati!

Dopo aver fatto una breve, ma corposa, introduzione sui cicli, andiamo oggi a vedere finalmente le prime implementazioni che utilizzano quello che abbiamo definito ciclo precondizionale.

In Java, come in molti altri linguaggi di programmazione, questo tipo di ciclo viene tradotto con il termine while, che in italiano può essere tradotto con "finchè, fino a quando".

Sintassi

Vediamo, prima di tutto, la sintassi di questo costrutto:

while (condizione) {
  /*Corpo del ciclo*/
}

La definizione sintattica concorda pienamente con la definizione teorica. Se ragioniamo sul fatto che le istruzioni vengono eseguite una dopo l'altra, riusciamo subito a capire che la condizione per cui il ciclo continua ad iterare viene controllata prima dell'esecuzione del corpo. Da qui, capiamo che stiamo avendo a che fare con un ciclo precondizionale.

Condizione o guardia del ciclo 

Vale la pena ribadire alcuni concetti fondamentali riguardanti le condizioni. 

É bene ricordare il fatto che, nel momento in cui ci si trova a dover fare dei controlli, si ha a che fare con elementi dell'algebra booleana. Proprio per questo motivo, valgono le regole che abbiamo definito precedentemente. 

Una nozione fondamentale da conoscere è che le iterazioni vengono eseguite per vero. Significa che i cicli continuano ad iterare sino a quando la condizione è vera. Quindi, ogni volta che scriveremo un ciclo, assumeremo che si continui ad eseguire sino a quando la guardia è vera.

Esempio 1: Stampa dei numeri da 0 a 10

Il primo semplice esempio che vale la pena vedere è il caso in cui vogliamo stampare i numeri da 0 a 10.

public class Main{
  public static void main(String[] args){
    int i = 0;
    while (i <= 10) {
      System.out.println(i);
      i++;
    }
  }
}

L'idea è quindi quella di dichiarare una variabile rappresentante il numero da stampare e di inizializzarla subito a 0.

Dopodichè, si vogliono stampare i numeri fino a dieci, quindi la condizione sarà i <= 10. Si deve quindi continuare ad iterare sino a quando la variabile i ha valore minore uguale di dieci. 

Il corpo del ciclo è relativamente semplice. É composto dall'istruzione per stampare la variabile i, e successivamente vi è l'incremento della variabile.

Un dettaglio alquanto importante è il fatto che anche il corpo del ciclo sia contenuto in una coppia di parentesi graffe. Java permette di omettere queste parentesi, a patto che il corpo del ciclo sia composto di una e una sola istruzione. Personalmente, evito sempre di farlo anche in un'ottica di futuro ampliamento del codice. Fino a quando il codice rimane così com'è, non vi sono problemi. I problemi iniziano ad insorgere quando va ampliato, dal momento in cui gli errori relativamente al posizionamento delle parentesi graffe sono alquanto comuni.

Esempio 2: Stampa di tutti i numeri pari fino ad un certo limite

Un altro esempio che vale la pena analizzare è la situazione in cui si vogliono stampare tutti i numeri pari da 0 sino ad un limite dato dall'utente.

Vediamo subito il codice.

public class Main{
  public static void main(String[] args){
    int i = 0;
    int limite = 100;
    while (i <= limite) {
      if(i%2 == 0){
        System.out.println(i);
      }
      i++;
    }
  }
}

In questo caso, la complessità di questo codice aumenta leggermente. Si nota infatti che è composto dall'incremento che avevamo già prima. É presente inoltre un if al suo interno. Implicitamente, capiamo che i vari costrutti possono essere annidati uno dentro l'altro.

L'idea alla base di questo esercizio è quella di scorrere tutti i numeri, e scegliere di volta in volta quali vadano stampati o no. A questo proposito vale la pena ricordare il significato della condizione all'interno dell'if. 

Scrivere i % 2 == 0 significa che stiamo controllando che il resto della divisione per due di i sia zero. Fondamentalmente, è il tipico controllo che effettuiamo per capire se un numero è pari o no. Al contrario, per controllare se volessimo stampare tutti i numeri dispari, dovremmo modificare l'if come segue:

if(i%2 == 1){
  System.out.println(i);
}

Questo perchè un numero dispari non è altro che un numero che, quando viene diviso per due, restituisce come resto 1.

Esempio 2: soluzione alternativa

Una soluzione alternativa e ben più semplice può essere la seguente:

public class Main{
  public static void main(String[] args){
  int i = 0;
  int limite = 100;
    while (i <= limite) {
      System.out.println(i);
      i=i+2;
    }
  }
}

Esempio 3: stampa di un rettangolo di *

Un terzo esempio che vale la pena vedere prevede la stampa di un rettangolo, composto interamente di *.

Non è un esempio che avrà un'utilità diretta durante le quotidiane esperienze di programmazione, ma ci aiuta a capire come è possibile annidare due cicli.

Come al solito, vediamo subito il codice per poi commentarlo.

public class Main{
  public static void main(String[] args){
    int base = 5;
    int altezza = 4;
    int i = 0;
    int j = 0;
    while(i < altezza){
      while(j < base){
        System.out.print("*");
        j++;
      }
      i++;
      j = 0;
    }
  }
}

Rispetto ai due esempi precedenti, questo codice all'apparenza è decisamente più complicato, ma vedremo insieme che non è così.

L'idea alla base è che possiamo assolvere questo semplice compito stampando una serie di linee composte di asterischi. In particolare, le linee saranno lunghe quanto la base, e il numero di linee da stampare è determinato dalla variabile altezza.

Per cui, ho scritto il ciclo più esterno, avente come condizione i < altezza, grazie al quale siamo in grado di iterare un numero di volte pari ad altezza. Questo ci serve per stampare le linee orizzontali.

Il ciclo più interno ha come condizione j < base, grazie al quale riusciamo a stampare una linea orizzontale di asterischi. Quindi, combinando questi due cicli, riusciamo a stampare una figura composta. 

L'output di questo programma, sarà il seguente: 

*****

*****

*****

*****

Conclusioni

Per studiare il comportamento del ciclo while ho fornito tre esempi piuttosto emblematici, che mostrano tre caratteristiche fondamentali di questo costrutto. 

Abbiamo visto un esempio basilare, dopodichè abbiamo analizzato come sia possibile creare cicli più complessi e infine, con l'ultimo esempio. 

Anche per questa volta è tutto. Come sempre, vi invito a sperimentare e fare test

Alessio Mungelli

Computer Science student at UniTo (University of Turin), Network specializtion, blogger and writer. I am a kind of expert in Java desktop developement with interests in AI and web developement. Unix lover (but not Windows hater). I am interested in Linux scripting. I am very inquisitive and I love learning new stuffs.