Array come Oggetti in Java

Concetti Chiave

Gli array in Java sono oggetti e hanno un attributo speciale chiamato length che indica la loro dimensione.
Il membro length degli array può essere utilizzato per gestire dinamicamente la dimensione degli array, come ad esempio in una classe Stack.
La creazione di stack di dimensioni variabili diventa semplice grazie alla proprietà length degli array.

Array come Oggetti

Gli array in Java sono stati introdotti nelle lezioni precedenti, prima che venissero trattate le classi.

Ora che abbiamo studiato le classi, possiamo fare un'importante osservazione sugli array: sono implementati come oggetti, cioè sono istanze di oggetti a tutti gli effetti.

Per questo motivo, esiste un attributo speciale degli array che sarà utile sfruttare. In particolare, la dimensione di un array, (cioè, il numero di elementi che un array può contenere) si trova nella sua variabile d'istanza length. Tutti gli array possiedono questa variabile, e conterrà sempre la dimensione dell'array.

Ecco un programma che dimostra questa proprietà:

// Questo programma dimostra il membro di array length.
class Lunghezza {
    public static void main(String[] args) {
        int[] a1 = new int[10];
        int[] a2 = {3, 5, 7, 1, 8, 99, 44, -10};
        int[] a3 = {4, 3, 2, 1};

        System.out.println("La lunghezza di a1 è " + a1.length);
        System.out.println("La lunghezza di a2 è " + a2.length);
        System.out.println("La lunghezza di a3 è " + a3.length);
    }
}

Questo programma visualizza il seguente output:

La lunghezza di a1 è 10
La lunghezza di a2 è 8
La lunghezza di a3 è 4

Come si può vedere, viene visualizzata la dimensione di ciascun array. Si noti che il valore di length non ha nulla a che vedere con il numero di elementi che sono effettivamente in uso. Riflette solamente il numero di elementi per cui l'array è stato allocato.

È possibile sfruttare il membro length in molte situazioni. Ad esempio, ecco una versione migliorata della classe Stack vista in precedenza.

Come si ricorderà, le versioni precedenti di questa classe creavano sempre una pila da dieci elementi. La versione seguente consente invece di creare stack di qualsiasi dimensione.

Il valore di stck.length viene utilizzato per evitare che lo stack venga sovraccaricat0.

// Classe Stack migliorata che usa il membro di array length.
class Stack {
    private int[] stck;
    private int cima;

    // allocare e inizializzare lo stack
    Stack(int dimensione) {
        stck = new int[dimensione];
        cima = -1;
    }

    // Inserisce un elemento sulla cima dello stack
    void push(int elemento) {
        if(cima == stck.length - 1) // usa il membro length
            System.out.println("Lo stack è pieno.");
        else
            stck[++cima] = elemento;
    }

    // Estrae un elemento dalla cima dello stack
    int pop() {
        if(cima < 0) {
            System.out.println("Stack vuoto.");
            return 0;
        }
        else
            return stck[cima--];
    }
}

class TestStack {
    public static void main(String[] args) {
        Stack mioStack1 = new Stack(5);
        Stack mioStack2 = new Stack(8);

        // inserire alcuni numeri nella pila
        for(int i = 0; i < 5; i++) mioStack1.push(i);
        for(int i = 0; i < 8; i++) mioStack2.push(i);

        // estrarre quei numeri dalla pila
        System.out.println("Stack in mioStack1:");
        for(int i = 0; i < 5; i++)
            System.out.println(mioStack1.pop());

        System.out.println("Stack in mioStack2:");
        for(int i = 0; i < 8; i++)
            System.out.println(mioStack2.pop());
    }
}

Consiglio

Dimensioni dinamiche degli Stack

Si noti che il programma crea due stack: uno profondo cinque elementi e l'altro profondo otto elementi. Come si può osservare, il fatto che gli array conservino automaticamente le informazioni sulla propria lunghezza rende semplice la creazione di stack di qualsiasi dimensione.