Codice: Seleziona tutto
public class Reggie {
public static void main(String args[]){
String reggieno = "Il corpo di Reggie non è pronto";
String reggiesi = "Il corpo di Reggie è pronto";
double min = 0.3;
double max = 0.7;
double valore = Math.random();
System.out.println(valore);
if(valore < min || valore > max){
System.out.println(reggieno);
}else{
System.out.println(reggiesi);
}
}
}In Java le operazioni basilari sono cinque:
addizione +
sottrazione -
moltiplicazione *
divisione /
divisione intera %
Le prime quattro sono le classiche operazioni matematiche che tutti conoscono, mentre la divisione intera dà, come risultato, il resto della divisione.
Ad esempio, 5 % 2 = 1, oppure 9 % 3 = 0.
Tutti i risultati delle operazioni possono essere salvati in variabili, però bisogna stare attenti a scegliere un tipo di variabile che possa contenere il valore: non possiamo certo salvare il risultato di una moltiplicazione in una variabile booleana, ad esempio.
Le operazioni possono essere anche tra variabili, purchè siano dei tipi numerici: se si facesse una somma tra due char o string, come risultato avremmo la concatenazione dei valori.
Codice: Seleziona tutto
int uno = 5;
String due = "bla";
//differenza tra il + aritmetico e + per la concatenazione
System.out.println(uno+uno);
System.out.println(due+due);Oltre a queste operazioni “classiche”, ve ne sono altre, che sono delle abbreviazioni di altre: prendiamo in considerazione due variabili numeriche, n e m (m può anche essere un numero).10
blabla
n += m corrisponde a n = n + m
n *= m corrisponde a n = n * m
n -= m corrisponde a n = n - m
n /= m corrisponde a n = n / m
n %= m corrisponde a n = n % m
n++ o ++n corrisponde a n = n + 1
n-- o --n corrisponde a n = n – 1
Questi ultimi due comandi sono molto utilizzati nei cicli. C'è una lieve differenza tra n++ e ++n, e cioè che nel primo caso prima viene letta la variabile e poi aggiornata, mentre nell'altro è il contrario (stessa cosa anche per n-- e –n). Vi consiglio di usare la prima versione.
Cos'è un ciclo?
Nella programmazione, molto spesso, si deve ricorrere ai cicli, delle particolari istruzioni che permettono di ripetere più volte un'operazione, se si rispettano certe condizioni. In Java vi sono tre cicli: il while, il do-while e il for. Essi differiscono l'uno dall'altro per semantica ed esecuzione.
Ciclo while – si scrive la parola chiave while, seguita da parentesi tonde; dentro di esse va inserito un valore booleano. Dopo le parentesi tonde, si deve aprire un blocco di codice, utilizzando le solite parentesi graffe. Il programma “entra” nel ciclo solo se la condizione del booleano è verificata, ed esegue tutto ciò che trova nel blocco di codice; una volta finito, torna a verificare se la condizione è ancora valida. Se lo è, ripete il ciclo, sennò salta il blocco di codice e passa ad un'istruzione successiva.
Codice: Seleziona tutto
//ciclo while che somma il valore di tre per 3 e lo stampa (finchè tre è minore di 10)
int tre = 1;
while(tre < 10){
tre += 3;
System.out.println(tre);
}Ciclo do-while – si scrive la parola chiave do, si apre un blocco di codice con le parentesi graffe, si scrive il codice da ciclare (come nel while), e una volta chiuso si scrive while(boolean);. Il programma esegue tutte le istruzioni contenute nel “do”, e poi controlla se la condizione nel “while” è valida: se lo è, torna ad eseguire il codice all'interno del “do”, sennò passa alle istruzioni successive.4
7
10
La differenza tra il while e il do-while è che nel primo caso il contenuto del ciclo potrebbe non essere mai eseguito, se già la prima volta la condizione non è verificata, mentre nel secondo caso il ciclo viene eseguito almeno una volta.
Codice: Seleziona tutto
//ciclo do-while che moltiplica il valore di quattro per 2 e lo stampa (finchè quattro è minore di 30)
int quattro = 2;
do{
quattro *= 2;
System.out.println(quattro);
}while(quattro < 30);Ciclo for – si scrive la parola chiave for, seguita da parentesi tonde. In esse vanno tre comandi: il primo è la dichiarazione di una variabile, il secondo è la condizione da verificare (in cui quasi sempre compare la variabile appena dichiarata), e il terzo è l'ultima operazione che viene effettuata, prima del controllo della condizione. I tre comandi vanno divisi tra loro con dei punto e virgola. Come nel “while”, anche il codice scritto all'interno del for potrebbe non essere mai eseguito, se la condizione non è valida sin dalla prima lettura.4
8
16
32
Codice: Seleziona tutto
//ciclo for che divide cinque per due e lo stampa (finchè non è uguale a 0)
for(int cinque = 8 ; cinque != 0; /*in questo caso non c'è l'incremento*/){
cinque /= 2;
System.out.println(cinque);
}
All'interno di un ciclo si può scrivere qualunque istruzione che può essere scritta all'interno di un metodo, anche dei costrutti if-else o altri cicli; in questo caso si parla di cicli annidati.4
2
1
0
Ora vedremo che i cicli sono estremamente utili per la lettura e la modifica degli array.
Cosa succede se un ciclo viene eseguito all'infinito?
Possono sorgere dei casi in cui il programma entra in un loop infinito, cioè un ciclo in cui la condizione è sempre vera, ma se succede è perchè c'è qualcosa di sbagliato nel codice: i loop infiniti sono il male. Se accade, il programma va nel cosidetto stack overflow, cioè si riempe la pila dello stack (una memoria virtuale e temporanea in dotazione alla Java Virtual Machine) e il programma non può continuare.
Cos'è un array?
Un array (vettore in italiano, anche se esiste anche l'oggetto vector che è leggermente diverso) è un contenitore “lineare” di tipi primitivi o oggetti; le stesse stringhe sono a loro volta array di caratteri.
Per dichiarare un array, si procede così:
tipo primitivo/oggetto[] – la prima parola è il tipo primitivo o il tipo di oggetti che l'array conterrà: questo significa che in un stesso array non ci possono essere stringhe e numeri, insieme. Le parentesi quadre vuote indicano che quella non è una variabile ma un array.
nome – ovviamente anche gli array devono avere un nome.
Se si vuole solo dichiarare l'array, basta mettere il solito punto e virgola, se invece si vuole proseguire con l'assegnazione si mette =.
Codice: Seleziona tutto
//dichiarazione array
int[] array;Ci sono due modi per l'assegnazione di un array.
Primo modo:
new – parola chiave, indica che stiamo istanziando un nuovo oggetto.
tipo primitivo/oggetto[grandezza] – come prima, va di nuovo specificato il tipo di dati che andranno all'interno dell'array, e stavolta nelle parentesi quadre va inserito il numero di valori da inserire. Una volta scelta una grandezza, non si può modificarla; se si fa una seconda assegnazione, l'array non sarà quello vecchio, ma uno nuovo con lo stesso nome.
In questo caso, però, l'array è vuoto: per inserire i dati si opera in questo modo.
nome_array[indice] = valore da inserire – si scrive il nome dell'array, seguito dalle parentesi quadre, in cui è scritto l'indice in cui andrà inserito il valore, l'uguale, e il valore da inserire. Gli indici degli array partono da 0 e non da 1, per cui si deve fare attenzione: se l'array è grande 10, ha gli indici da 0 a 9: se scrivete 10, il compilatore vi segnalerà con un OutOfBoundsException, una scorrettezza del programma. Se volete riempire completamente l'array, dovrete ripetere l'istruzione per ogni indice, oppure fare un ciclo (for o while). Ovviamente, se si fa un ciclo, il valore inserito sarà uguale per tutti o comunque sarà ordinato, mentre se si inseriscono “manualmente” c'è più libertà.
Codice: Seleziona tutto
//assegnazione lunghezza array (1)
array = new int[5];Codice: Seleziona tutto
//assegnazione valori array (1)
array[0] = 394;
array[1] = 666;
//...
array[4] = 1337;Codice: Seleziona tutto
//assegnazione con il ciclo while (1)
int indice = 0;
while(indice < array.length){
array[indice] = indice; //il valore nell'array corrisponde all'indice
indice++;
}
//assegnazione con il ciclo for (1)
for(int index = 0; index < array.length; index++){
array[index] = index; //come sopra
}{valore1, valore2, valore3, … , valoreN} – metodo di assegnazione molto più comodo, in caso di array corti: si aprono delle parentesi graffe e si scrivono i valori che vanno inseriti; l'array sarà automaticamente della lunghezza pari al numero di valori inseriti, e gli indici uguali all'ordine in cui i valori sono stati inseriti. Se si vogliono modificare uno o più valori, si deve procedere come illustrato sopra. Sia nel primo che nel secondo caso, al termine di ogni assegnazione, va posto il punto e virgola.
Codice: Seleziona tutto
//dichiarazione e assegnazione array (2)
String[] vettore = {"Red", "puzza", "di", "rose", "rosse"};Come per l'assegnazione nel primo metodo, anche per la modifica/lettura/quello che vi pare si ricorre ad un ciclo. Ad esempio, se si vogliono stampare tutti gli elementi di un array, si procede come sopra: si crea una variabile che funga da indice, inizialmente pari a 0; si pone come condizione che l'indice sia minore della lunghezza dell'array, all'interno del ciclo si scrive l'istruzione di stampa, e poi si incrementa l'indice.
Codice: Seleziona tutto
//stampa
for(int index2 = 0; index2 < vettore.length; index2++){
System.out.println(vettore[index2]);
}Gli array possono contenere altri array?Red
puzza
di
rose
rosse
Certamente. Gli array possono contenere a loro volta altri array, e in questo caso si parla di matrici bidimensionali. Ovviamente, le matrici possono avere anche più tridimensionali (array che contengono array, che a loro volta contengono altri array). Io vi parlerò solo di matrici a due dimensioni, per non incasinarvi troppo
Come si costruisce una matrice?
La dichiarazione di una matrice è identica a quella di un array, con l'unica differenza che con il tipo vanno scritte due coppie di parentesi quadre, e non una.
Anche l'assegnazione funziona come negli array, e abbiamo entrambe le possibilità: nel primo caso, la differenza è che va specificata anche la grandezza della seconda dimensione, mentre nel secondo caso i vari elementi sono a loro volta degli array. In questo caso, le dimensioni degli array “interni” possono differire.
Codice: Seleziona tutto
//dichiarazione e assegnazione di una matrice (1)
char[][] quadrato = new char[8][8];
//dichiarazione e assegnazione di una matrice (2)
int[][] matrix = {{1, 2, 3}, {4, 5}, {6}};Per “navigare” s'intende accedere liberamente ad un oggetto o una struttura dati, per leggere o modificare i dati al suo interno. Nel caso di una matrice bidimensionale, si utilizzano due cicli annidati. In questo caso, andremo a prendere la matrice 8x8, e la utilizzeremo per stampare un quadrato di asterischi.
Codice: Seleziona tutto
//assegnazione valori e stampa (facciamo un quadrato di asterischi di lato 8)
for(int i = 0; i < quadrato.length; i++){
for(int j = 0; j < quadrato[i].length; j++){
System.out.print('*');
}
System.out.println('\n');
}Si inizializza il ciclo più esterno, che ci permetterà di scorrere le righe della matrice, e che va scritto come un normale ciclo che scorre gli elementi di un array. Si inizializza subito il secondo ciclo, che permette di scorrere le colonne; stavolta però non prenderemo in considerazione il numero di righe, bensì il numero di colonne, per questo utilizzeremo il comando array[indicerighe].length. All'interno di questo secondo ciclo inseriamo il comando di stampa (senza però andare a capo, ecco perchè usiamo System.out.print() e non System.out.println()). Usciti dal ciclo interno, mettiamo un comando che ci permette di andare a capo ogni volta che passiamo ad una nuova riga. Per farlo o si stampa il carattere speciale \n, oppure si da la stringa vuota ”” come parametro a System.out.println().********
********
********
********
********
********
********
********
Risultato
Abbiamo qua tutto il codice usato nella soluzione e quanto viene stampato.
Codice: Seleziona tutto
public class RoseRosse {
@SuppressWarnings("unused")
public static void main(String args[]){
int uno = 5;
String due = "bla";
//differenza tra il + aritmetico e + per la concatenazione
System.out.println(uno+uno);
System.out.println(due+due);
//ciclo while che somma il valore di tre per 3 e lo stampa (finchè tre è minore di 10)
int tre = 1;
while(tre < 10){
tre += 3;
System.out.println(tre);
}
//ciclo do-while che moltiplica il valore di quattro per 2 e lo stampa (finchè quattro è minore di 30)
int quattro = 2;
do{
quattro *= 2;
System.out.println(quattro);
}while(quattro < 30);
//ciclo for che divide cinque per due e lo stampa (finchè non è uguale a 0)
for(int cinque = 8 ; cinque != 0; /*in questo caso non c'è l'incremento*/){
cinque /= 2;
System.out.println(cinque);
}
//dichiarazione array
int[] array;
//assegnazione lunghezza array (1)
array = new int[5];
//assegnazione valori array (1)
array[0] = 394;
array[1] = 666;
//...
array[4] = 1337;
//assegnazione con il ciclo while (1)
int indice = 0;
while(indice < array.length){
array[indice] = indice; //il valore nell'array corrisponde all'indice
indice++;
}
//assegnazione con il ciclo for (1)
for(int index = 0; index < array.length; index++){
array[index] = index;
}
//dichiarazione e assegnazione array (2)
String[] vettore = {"Red", "puzza", "di", "rose", "rosse"};
//stampa
for(int index2 = 0; index2 < vettore.length; index2++){
System.out.println(vettore[index2]);
}
//dichiarazione e assegnazione di una matrice (1)
char[][] quadrato = new char[8][8];
//dichiarazione e assegnazione di una matrice (2)
int[][] matrix = {{1, 2, 3}, {4, 5}, {6}};
//assegnazione valori e stampa (facciamo un quadrato di asterischi di lato 8)
for(int i = 0; i < quadrato.length; i++){
for(int j = 0; j < quadrato[i].length; j++){
System.out.print('*');
}
System.out.println('\n');
}
}
}
Esercizio10
blabla
4
7
10
4
8
16
32
4
2
1
0
Red
puzza
di
rose
rosse
********
********
********
********
********
********
********
********
Stampare un triangolo (rettangolo) di asterischi, utilizzando le matrici e i cicli annidati.
That is not dead which can eternal lie, and with strange aeons, even death may die.
