I vettori
Un vettore, quindi, è una collezione finita di elementi omogenei,
ossia dello stesso tipo,
disposti secondo una sola dimensione.
Per individuare un elemento del vettore occorre specificare il
valore del suo indice, come indicato nel seguito.
Esso può
assumere i valori da 0 a n - 1,
dove n è il numero di elementi dell
vettore (indice
zero-based).
Graficamente possiamo immaginarlo come mostrato nella figura che segue:
Come per i tipi di dato visti finora, anche per utilizzare un vettore occorre dichiararlo.
La dichiarazione di un vettore deve specificare:
- il tipo degli elementi, seguito da una parentesi quadra aperta ed una chiusa
- il nome della variabile o identificatore
Vediamo un esempio di dicharazione di un vettore direttamente in codice Java.
// dichiarazione di un vettore di interi
int[] mioVettore;
// Java permette di dichiarare un vettore
// anche utilizzando questa seconda sintassi
int mioVettore[];
In generale, la dichiarazione di un vettore deve avere la forma seguente:
A differenza dei tipi di dato primitivi utilizzati finora, affinché sia possibile utilizzare un vettore occorre allocare lo spazio in memoria centrale per poter contenere i suoi elementi.
Questa operazione, che prende il nome di allocazione, deve specificare il numero di elementi che il vettore deve poter contenere.
Essa è effettuata attraverso una istruzione con la struttura seguente:
Vediamo alcuni esempi di allocazione di vettori attraverso il codice Java.
// allocazione di un vettore di 10 interi
mioVettore = new int[10];
// allocazione di un vettore di 100 decimali
mioVettore = new float[100];
// allocazione di un vettore di 50 booleani
mioVettore = new boolean[50];
// allocazione di un vettore di 50 stringhe alfanumeriche
mioVettore = new String[50];É anche possibile dichiarare ed allocare un vettore in un'unica istruzione, come mostrato nel frammento di codice che segue.
// dichiarazione ed allocazione di un vettore di 10 interi
int[] mioVettore = new int[10];
// dichiarazione ed allocazione di un vettore di 100 decimali
float[] mioVettore = new float[100];
// dichiarazione ed allocazione di un vettore di 50 booleani
boolean[] mioVettore = new boolean[50];
// dichiarazione ed allocazione di un vettore di 50 stringhe alfanumeriche
String[] mioVettore = new String[50];
Dopo aver allocato un vettore, è possibile accedere ai suoi elementi, indicando, tra le
parentesi
quadre che seguono il
suo identificatore, l'indice della posizione dell'elemento.
Gli indici degli elementi del vettore assumono i valori dell'intervallo 0 .. numero di elementi
-1.
Quindi, per accedere al primo elemento di un vettore di 10 elementi, occorrerà utilizzare
l'istruzione
In generale, per accedere all'elemento alla posizione i di un vettore occorre utilizzare l'istruzione
in quanto l'indice di un elemento corrisponde alla sua posizione nel vettore decrementata di uno.
Vediamo alcuni esempi di utilizzo dei vettori, nel seguente frammento di codice Java.
// dichiarazione ed allocazione di un vettore di 10 interi
int[] mioVettore = new int[10];
// scrittura del valore 50 nel primo elemento del vettore
mioVettore[0] = 50;
// scrittura del valore 100 nel terzo elemento del vettore
mioVettore[2] = 100;
// copia del valore del quinto elemento nel 10 elemento
mioVettore[9] = mioVettore[4];
// incremento del valore contenuto nel 15 elemento
mioVettore[14]++;
// inizializzazione con valore 0 di tutti
// gli elementi di un vettore di n elementi
for (int i = 0; i < n; i++) {
mioVettore[i] = 0;
}
// stampa di tutti i valori contenuti
// negli elementi di un vettore di n elementi
for (int i = 0; i < n; i++) {
System.out.println(mioVettore[i]);
}
Per conoscere la lunghezza del vettore, ossia il suo numero di
elementi, Java mette a
disposizione la proprietà length.
Questa può essere utilizzata, ad esempio, in una funzione che riceve un vettore come parametro
di
input affinché ne stampi i suoi valori o ne inizializzi gli elementi con valore nullo.
Vediamone un esempio, nel seguente frammento di codice Java.
// funzione che stampa gli elementi di un vettore
public static void stampaVettore(int[] vett) {
for (int i = 0; i < vett.length; i++) {
System.out.println(vett[i]);
}
}
// funzione che inizializza gli elementi di un vettore
// con valore nullo
public static void azzeraVettore(int[] vett) {
for (int i = 0; i < vett.length; i++) {
vett[i] = 0;
}
}E' anche possibile inizializzare un vettore con valori statici nella stessa istruzione di allocazione o dichiarazione.
In questo caso non è necessario specificare il numero di elementi del vettore nell'istruzione di allocazione, in quanto esso viene desunto dal numero di elementi effettivamente utilizzati per l'inizializzazione.
Di seguito sono evidenziati alcuni esempi di tale tipo di inizializzazione.
// dichiarazione e successiva allocazione ed inizializzazione
// di un vettore di 10 interi, con valori tutti nulli
int[] mioVettore;
mioVettore = new int[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // il vettore conterrà 10 elementi
// dichiarazione, allocazione ed inizializzazione
// di un vettore di 10 interi, con valori tutti nulli
// in un'unica istruzione
int[] mioVettore = new int[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // il vettore conterrà 10 elementi
// dichiarazione, allocazione ed inizializzazione
// di un vettore di 10 interi, con i valori delle
// prime 10 decine in un'unica istruzione
int[] decine = new int[] {10, 20, 30, 40, 50, 60, 70, 80, 90, 100}; // il vettore conterrà 10 elementi
// dichiarazione, allocazione ed inizializzazione
// di un vettore di 3 stringhe
// in un'unica istruzione
String[] momentiGiornata = new String[] {"mattino", "pomeriggio", "sera"}; // il vettore conterrà 3 elementi
// dichiarazione, allocazione ed inizializzazione
// di un vettore con le vocali
// in un'unica istruzione
char[] vocali = new char[] {'a', 'e', 'i', 'o', 'u'}; // il vettore conterrà 5 elementi