Dalle variabili agli array
Le variabili consentono di memorizzare e manipolare dei dati durante l'esecuzione di un programma, ma hanno delle limitazioni:
  • ogni variabile è associata ad un singolo dato.

Spesso invece ci troviamo a dover manipolare dati in qualche modo omogenei, per esempio un insieme di interi di cui vogliamo trovare il minimo, i voti degli esami di profitto, etc...

In questi casi può essere conveniente far riferimento ai dati in modo uniforme. 

// Scrivere un programma che chiede tre stringhe 
// e un intero i (compreso tra 1 e 3) all'utente,
// e poi stampa la i-esima stringa.

public class StampaUna_di_3 {
    public static void main(String [] args) {
        String s1, s2, s3;
        System.out.print("Dammi una stringa: ");
        s1 = Input.readLine();
        System.out.print("Dammi una stringa: ");
        s2 = Input.readLine();
        System.out.print("Dammi una stringa: ");
        s3 = Input.readLine();
        System.out.print("Quale stringa vuoi che  stampi? (1-3): ");
        int k =  Input.readInt();
        switch ( k ) {
           case 1: System.out.println(s1); break;
           case 2: System.out.println(s2); break;
           case 3: System.out.println(s3); break;
           default: System.out.println("Intero non valido!");
        }
    }
}

Un array è una sequenza di variabili indirizzabili con un indice intero.

Gli array

  • sono composti da elementi omogenei (tutti dello stesso tipo)
  • ogni elemento è identificato all'interno dell'array da un numero d'ordine detto indice dell'elemento
  • il numero di elementi dell'array è detto lunghezza (o dimensione) dell'array. 

    public class StampaUna_di_3array {

    public static void main(String [] args) {

        final int N = 3;
        // Costruisco array con N stringhe
        String [] array = new String[N]; 

        // leggo e inserisco le stringhe nell'array
        for (int i = 0; i < N; i++) {   
            System.out.print("Dammi una stringa: ");
            array[i] = Input.readLine();
        }

        // chiede all'utente quale  stringa  deve  stampare e la stampa 
        System.out.print("Quale stringa vuoi che stampi? (1-3):");
        int k = Input.readInt();
        // Adesso potremmo sostituire facilmente switch con if!!
        switch ( k ) {
           case 1: case 2: case 3:
               System.out.println(array[k-1]); break;
           default: System.out.println("Hai scritto un intero non valido!");
        }
    }
}


  Dichiarazione e creazione di array

Abbiamo detto che un array di lunghezza n è una collezione di n variabili dello stesso tipo, distinguibili l'una dall'altra per mezzo di un indice, cioè di un numero intero progressivo che può assumere valori tra 0 e n-1.

Come si crea un array?

In Java gli array sono oggetti e quindi vanno creati utilizzando l'operatore new.

La sintassi dell'operatore di creazione è però diversa da quella prevista per gli altri oggetti: per creare un oggetto array dobbiamo utilizzare new seguito dal nome del tipo base e da un'espressione di tipo int racchiusa tra parentesi quadre.

In generale, una dichiarazione di variabile di tipo array con inizializzazione ha la seguente forma:
 

<tipo>[] <nomeArray> = new <tipo>[<lunghezza>];

dove:

  • <tipo> è chiamato il tipo base dell'array, e può essere un qualunque tipo di dato Java (un tipo elementare o una classe)
  • <nomeArray> è la variabile di tipo array
  • <lunghezza> è la lunghezza dell'array che si costruisce 

Esempio:

int[] list;         // dichiara una variabile 
                    // di tipo 'array di int'
list = new int[5];  // assegna a list un array 
                    // di 5 elementi di tipo int


int[] list = new int[5]; // equivalente

Concettualmente, list è una sequenza di cinque variabili di tipo int, chiamate list[0], list[1], ..., list[4]

         
list[0]
list[1]
list[2]
list[3]
list[4]



  Gli array sono oggetti
Gli array sono realizzati in Java come oggetti di una classe opportuna (che viene dichiarata dinamicamente): questo si vede anche dall'uso della primitiva new per la creazione. 

Una dichiarazione di array consiste di due fasi:

  • creazione del riferimento,
  • allocazione dello spazio necessario a memorizzare gli elementi.

Gli array hanno una variabile di istanza length, il cui valore corrisponde al numero degli elementi contenuti nell'array. Tale informazione si trova in un campo (cioè come vedremo in una variabile interna all'oggetto) di nome length e di tipo int e non è quindi un metodo come nel caso della classe String. 

int[] list;

list = new int[5];

// crea un riferimento vuoto (null)

// crea un array di 5 interi 
// e ne assegna il riferimento a list


Quindi una variabile di tipo array è solo un riferimento (o puntatore) all'area di memoria dove viene allocato l'array.

L'operatore  new crea l'insieme di variabili che costituiscono l'array e anche la variabile length, e l'assegnamento le collega alla variabile list di tipo array.

Nel momento in cui viene creato l'array, tutti i valori sono inizializzati a

  • 0 (se il tipo base è numerico, come int[], double[], o char[]);
  • false (se il tipo base è booleano: boolean[]);
  • null (per un array di oggetti, come String[] o Rectangle[]).

La dimensione di un array è fissata al momento della creazione e non può essere cambiata a meno di creare un nuovo oggetto array (ma vedremo le classi ArrayList e Vector dove invece il cambiamento dinamico della dimensione è possibile).

Accesso agli elementi di un array

Per riferire i singoli elementi di un array si usano le parentesi quadre:
  
<nomeArray>[<indice>] // denota la variabile di posizione
                      // <indice> dell'array <nomeArray>

Attenzione:
Il primo elemento di un array di lunghezza n ha indice 0, il secondo ha indice 1, e così via, fino all'ultimo elemento, che ha indice n-1 (analogamente alla numerazione dei caratteri che compongono una stringa).

Ad esempio, il quarto elemento dell'array list è list[3]; il seguente comando gli assegna il valore 10:

list[3] = 10;

Analogamente, per leggere il valore dell'elemento di indice 3 dell'array list, basta usare l'espressione list[3] come per qualsiasi variabile di tipo int; ad esempio si può stampare tale valore mediante il comando:
  

System.out.println("L'elemento di indice 3 vale " + list[3]);

Inizializzazione di un array
Le singole variabili di un array possono essere inizializzate in fase di dichiarazione (in modo analogo alle variabili di tipi primitivi). In questo caso la dichiarazione di array ha la seguente forma:

  <tipo>[] <nomeArray> = {<lista_valori>};

dove <lista_valori> è una sequenza di elementi, ciascuno di tipo <tipo>, separati da virgole.

In questo caso, il valore della variabile di istanza length viene automaticamente inizializzato al numero di elementi che compongono la lista.

Esempio:
  

 char[] vocali = {'a', 'e', 'i', 'o', 'u'};
 char c = vocali[4];
 System.out.println(c);
 System.out.println(vocali.length); 

 
 
 
// stampa u
// stampa 5

Si noti che length non è seguita da parentesi: si tratta infatti di una variabile istanza dell'oggetto array, non di un metodo (come nel caso delle stringhe).

Nota Storica
Come abbiamo visto, in Java una dichiarazione di variabile di tipo array ha la forma
 
<tipo>[] <nomeArray>;

Infatti, come sempre, in una dichiarazione di variabile il tipo precede il nome della variabile stessa. Tuttavia, per motivi storici, questa dichiarazione può anche essere scritta
  

<tipo> <nomeArray>[];


//ad esempio:
int list[] = new int[5];

che è la sintassi usata nei linguaggi C e C++. Analogamente, 

public static void main(String[] args){


// può essere scritto:
public static void main(String args[]){

Però questa sintassi alternativa non è molto significativa in Java e si raccomanda di evitarla!