ARRAY

Per assegnare più di un valore dello stesso tipo alla stessa variabile si usano gli array (detto anche vettore).

Gli array in Java sono degli oggetti : il programmatore deve preoccuparsi solo di conoscere l'interfaccia ed i metodi forniti.

Essendo un oggetto va dichiarato con new. Per dichiarare un array (2 modi che ottengono lo stesso risultato):

TipoDati[] Nome = new TipoDati[Dimensione];

TipoDati Nome[] = new TipoDati[Dimensione];

• TipoDati è il tipo di dati contenuti nell'array

• Nome è il nome scelto per la variabile che avrà come riferimento l'allocamento in memoria dell'oggetto
• [] indica che si sta definendo un array (si può mettere prima o dopo al nome a discrezione del programmatore)
• new l'operatore new serve a costruire l'oggetto
•Dimensione dice quanti elementi contiene l'array

Dichiarazione alternativa con inglobata l'inizializzazione degli elementi :

TipoDati[] Nome = {dato1,dato2,dato3,...daton};

L'accesso ai singoli elementi dell'array avviene nella maniera comune a molti linguaggi di programmazione ( C, C++, Pascal).

Nome[indice]

nota – è importante ricordarsi che il primo elemento di un array ha indice 0 e l'ultimo (numelementi-1).

Per scrivere nei vari elementi di un array si usa il simbolo di assegnazione :

Nome[indice] = valore compatibile con il tipo dell'array;
esempio
int pippo []=new int[20];//creato array con 10 elementi di tipo int
String nomi []={“pippo”, “pluto”, “minnie”}; //creato array 3 elementi tipo String
for(int i=0;i<pippo.length;i++);//genera gl'indici mediante la variabile i  
{
/* il ciclo termina utilizzando il metodo length che definisce la lunghezza dell'array  */
pippo[i]=100+i;
//stampa dei valori inseriti nell'array
System.out.println(“pippo con l'indice ”+i+” ha valore “+pippo[i]);
}
pippo[0] = 25; //assegna il valore intero 25 alla prima locazione
pippo[12] = 33; //assegna il valore intero 33 alla locazione 12, cioè alla tredicesima locazione



pippo[32] = 12;  //ERRORE : il valore dell'indice è troppo alto

pippo[15] = “ciao”; //ERRORE : il valore assegnato non è di tipo int ma è una stringa

for(int a=0;a<3;a++)

{

//stampa i tre nomi dell'array

System.out.println(“nome ”+a+” è “+nomi[a]);

}

Copia di array

Si può copiare un array con una semplice assegnazione:

array1 = array2;

ma dopo tale assegnazione entrambe le variabili fanno riferimento allo stesso array (STESSA AREA DI MEMORIA).

Questo non è necessariamente un errore in Java.
Esiste in Java un meccanismo di Garbage Collection (“raccolta spazzatura”): in cui la memoria non utilizzata viene periodicamente recuperata dalla JVM (Java Virtual Machine).

NOTA BENE: dato che ho un’unica area di memoria per array1 e array2 qualsiasi modifica fatta su una variabile si ripercuote sull’altra.

Esiste un metodo migliore per copiare un array in un altro: il metodo arraycopy della classe System.

System.arraycopy( sorgente,  indice_sorgente, destinazione, indice_destinazione, numero);

sorgente array da copiare
indice_sorgente posizione di inizio copia di sorgente
destinazione array in cui copiare
indice_ destinazione posizione di inizio copia per l'array destinazione
numero numero di elementi da copiare

Esempio: dati due array di numeri double, D1 e D2, copiare 3 elementi di D1 a partire dal secondo in D2 posizionandoli a partire dal quinto elemento di D2.

import java.util.Random; // per numeri casuali

class ArrayTest

{

public static void main (String args[]) 
{

int[] D1= new int[15];

int[] D2= new int[15];

double x;
int n,i;

// generatore num. casuali(istanza della classe Random

Random myRandom = new Random();
for(i=0;i<15;i++)
{
// genera numeri random fra  0 e 9

x = myRandom.nextDouble() * 10.0;

n = (int) x;
D1[i]=n;

// genera numeri random fra  100 e 1099

x =100.0 + myRandom.nextDouble() * 1000.0;

n = (int) x;
D2[i]=n;

}

// Prima della copia
for (i = 0; i < 15; i++) 
{
   System.out.println("D1[ "+i+"] = "+D1[i]+"   D2[ "+i+"] = "+D2[i]);
System.arraycopy(D1,1,D2,4,3);
}
// Dopo la copia
for (i = 0; i < 15; i++) 
{
 System.out.println("D1[ "+i+"] = "+D1[i]+"   D2[ "+i+"] = "+D2[i]);
}

Confronto di array

Ricordare sempre la distinzione fra oggetti ed il contenuto degli oggetti. Date le seguenti definizioni

int[] a={1,2,3,4};
int[] b={1,2,3,4};
if (a==b) .....

risulta che il confronto (a==b) restituisce false

Se invece si considera

OGGETTO ≠ CONTENUTO DELL'OGGETTO

int[] a={1,2,3,4};

int[] b={1,2,3,4);

b=a;
if(a==b) ......

ora il confronto (a==b) vale true, ma in realtà significa solo che le variabili a e b rappresentano la stessa zona di memoria.

Per CONFRONTARE I CONTENUTI degli oggetti bisogna utilizzare un metodo apposito (definito dall'utente se non disponibile).

Ad esempio la classe String definisce i metodi

boolean  equalsIgnoreCase(String s)

boolean equals(String s)
confrontano la stringa con s e restituiscono true o false.

int      compareTo(String s)

confronta la stringa con s e restituisce:
• 0 se sono uguali
• N>0 se s e precedente (in ordine alfabetico) • N<0 se è successiva.

Esempio

int n;
String prima="altopiano"; String seconda="mare";
n = seconda.compareTo(prima); // ora n e' maggiore di 0

Array multidimensionali

La dichiarazione di array multidimensionale è la naturale estensione di quanto giá visto

Definizione di un array bidimensionale:

TipoDati[][] Nome = new TipoDati[Dimens1][Dimens2];

Definizione di un array tridimensionale:

TipoDati[][][] Nome = new TipoDati[Dim1][Dim2][Dim3]; e cosí via per array N-dimensionali.

Alternativa :

TipoDati[][] Nome = {{dato1_1,d1_2},{d2_1,...d2_2}};

L'accesso avviene nella maniera seguente :

NomeVariabile[indice1][indice2]

NOTA: Un array multidimensionale è un array di array. È possibile definire array di dimensioni non uniformi.

Esempio

int Max_row=5;
int[][] Matrice = new int[Max_row][];
/* l'oggetto Matrice non e' ancora
   utilizzabile, perche' non e' ancora
   definito il numero delle colonne
 */
for(i=0; i<= Max_row; i++)

Matrice[i]= new int[n+1];
/* l'oggetto Matrice e' ora utilizzabile */