Un array o vettore in qualsiasi linguaggio di programmazione è una serie di valori ordinati attraverso un indice, in posizione x abbiamo il valore xVal. Vediamo attraverso un semplicissimo esempio come in Java vengono gestiti gli array.
package corso;
public class Main
{
public static void main(String[] args)
{
int iArrVal[] = {8, 4, 2, 13, 87, 45, 76, 34};
int iTot = 0;
for (int i = 0; i < iArrVal.length; i++)
iTot += iArrVal[i];
System.out.println("La somma del mio array è di: " +
iTot);
}
}
Come si vede nell’esempio abbiamo popolato un array con 8 numeri interi e dato che l’indice del primo elemento è zero, dobbiamo iterare l’array dalla posizione o indice 0 a 7. Possiamo anche iterare un array con il ciclo while, inserendo le giuste modifiche.
package corso;
public class Main
{
public static void main(String[] args)
{
int iArrVal[] = {8, 4, 2, 13, 87, 45, 76, 34};
int iTot = 0;
int i = 0;
while (i < iArrVal.length)
{
iTot += iArrVal[i];
i++;
}
System.out.println("La somma del mio array è di:" +
iTot);
}
}
In questo caso abbiamo inizializzato la variabile dell’indice i a zero ed abbiamo aumentato di una unità fino a raggiungere l’ultimo indice dell’array. Ma il modo più semplice per iterare un array in Java è in questa forma:
package corso;
public class Main
{
public static void main(String[] args)
{
int iArrVal[] = {8, 4, 2, 13, 87, 45, 76, 34};
int iTot = 0;
for (int iVal = 0; iVal < iArrVal.length; iVal++)
iTot += iVal;
System.out.println("La somma del mio array è di: " +
iTot);
}
}
abbiamo delle restrizioni con quest’ultimo costrutto, come il fatto di iterare solo in avanti o in sola lettura, ma si vede ad occhio che nei casi in cui si rientra in questo uso è preferibile utilizzare questo costrutto nei confronti degli altri. Un buon programmatore deve poter scrivere il meno codice sorgente possibile.
Un esempio di array che abbiamo avuto sempre sotto gli occhi è l’argomento della funzione principale del programma, String[] args, un array di stringhe delle opzioni della riga di comando del programma. Osservando la struttura della funzione principale del programma potete notare come le funzioni in Java, come del resto negli altri linguaggi di programmazione, siano composti dal tipo del valore di ritorno, nel caso della main è un tipo void o nullo, che cioè non ritorna valori, il nome della funzione e tra parentesi tonde gli argomenti della funzione stessa. Iniziamo con un esempio, implementando una delle più semplici funzioni, la somma di due numeri interi.
package corso;
public class Main
{
public static int mySomma(int a, int b)
{
return a + b;
}
public static void main(String[] args)
{
System.out.println(mySomma(12, 53));
}
}
Per il momento lasciamo stare le istruzioni public e static, ne parleremo nelle prossime lezioni quando studieremo le classi, per ora dovete concentrarvi su come implementare una funzione. Facciamo un altro esempio questa volta calcolando il fattoriale di un numero.
package corso;
public class Main
{
public static int myFattoriale(int a)
{
if (a > 5)
return 1;
int iFatt = 1;
for (int i = a; i > 1; i--)
iFatt *= i;
return iFatt;
}
public static void main(String[] args)
{
System.out.println("Il fattoriale di 5 è: " +
myFattoriale(5));
}
}
In questa funzione abbiamo deciso di non calcolare il fattoriale di numeri superiori a 5 ( con i nuovi computer potremmo benissimo aumentare questo limite, ma questo è solo un esempio ) perché come sapete il fattoriale aumenta moltissimo all’aumentare del numero da calcolare e per evitare possibili overflow ( saturazioni del buffer della memoria ) inseriamo un limite.
Ultimo argomento da trattare in questa lezione è la differenza tra dare per argomento un valore od un riferimento. Il primo caso riguarda tutti i tipi primitivi che abbiamo visto in una lezione precedente, mentre il secondo riguarda gli array e gli oggetti o classi che vedremo in una lezione futura. Cosa significa per valore o riferimento? Il primo vuol dire che viene passato il valore della variabile, mentre nel secondo caso viene passato l’indirizzo alla prima cella di memoria della variabile. Gli esempi che abbiamo fatto finora erano del primo caso, abbiamo sempre utilizzato il valore della variabile, questa volta inseriamo come argomento un array e vediamo se è possibile modificare alcuni suoi valori:
package corso;
public class Main
{
public static void RaddoppiaArray(int[] a)
{
for (int i = 0; i < a.length; i++)
a[i] *= 2;
}
public static void main(String[] args)
{
int iArrVal[] = {12, 45, 32, 76, 4, 87};
int iTot = 0;
for (int iVal = 0; iVal < iArrVal.length; iVal++)
iTot += iVal;
System.out.println("La somma dei numeri dell'array è : " +
iTot);
RaddoppiaArray(iArrVal);
iTot = 0;
for (int iVal 0 0; iVal < iArrVal.length; iVal++)
iTot += iVal;
System.out.println("La somma dei numeri del doppio
dell'array è : " + iTot);
}
}
se infatti provassimo ad implementare la stessa funzione per un tipo primitivo ecco cosa otterremmo:
package corso;
public class Main
{
public static void RaddoppiaValore(int a)
{
a *= 2;
}
public static void main(String[] args)
{
int iVal = 12;
System.out.println("Il numero è : " + iVal);
RaddoppiaValore(iVal);
System.out.println("Il numero è : " + iVal);
}
}
se eseguiamo il programma il valore non cambia e questo perché nella funzione abbiamo ricevuto il valore della variabile, mentre per un array o altro oggetto otterremmo l’indirizzo di memoria della prima cella, che quindi ci permette di cambiare il valore in memoria della variabile, quindi la variabile stessa.
<< Lezione Precedente – Inizio Corso – Lezione Successiva >>
