Array multidimensionali in Java

1. Panoramica

Un array multidimensionale in Java è un array che comprende array di dimensioni variabili come suoi elementi. Viene anche definito "un array di array" o "array irregolare" o "array irregolare".

In questo rapido tutorial, esamineremo più in profondità la definizione e il lavoro con array multidimensionali.

2. Creazione di array multidimensionali

Iniziamo esaminando i modi in cui possiamo creare un array multidimensionale:

2.1. La forma abbreviata

Un modo semplice per definire un array multidimensionale sarebbe:

int[][] multiDimensionalArr = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}};

Qui abbiamo dichiarato e inizializzato multiDimensionalArr in un unico passaggio.

2.2. Dichiarazione e quindi inizializzazione

Iniziamo dichiarando un array multidimensionale di dimensione tre:

int[][] multiDimensionalArr = new int[3][];

Qui, abbiamo omesso di specificare la seconda dimensione poiché varierà .

Successivamente, andiamo oltre dichiarando e inizializzando i rispettivi elementi all'interno di multiDimensionalArr :

multiDimensionalArr[0] = new int[] {1, 2}; multiDimensionalArr[1] = new int[] {3, 4, 5}; multiDimensionalArr[2] = new int[] {6, 7, 8, 9};

Possiamo anche dichiarare semplicemente i suoi elementi senza inizializzarli:

multiDimensionalArr[0] = new int[2]; multiDimensionalArr[1] = new int[3]; multiDimensionalArr[2] = new int[4];

Questi possono essere successivamente inizializzati, ad esempio utilizzando gli input dell'utente.

Possiamo anche usare il metodo java.util.Arrays.fill per inizializzare gli elementi dell'array:

void initialize2DArray(int[][] multiDimensionalArray) { for (int[] array : multiDimensionalArray) { Arrays.fill(array, 7); } } 

Tutti gli elementi negli array vengono inizializzati con lo stesso valore.

3. Rappresentazione della memoria

Come sarà la rappresentazione della memoria del nostro multiDimensionalArr ?

Come sappiamo, un array in Java non è altro che un oggetto, i cui elementi potrebbero essere primitivi o riferimenti. Quindi, un array bidimensionale in Java può essere pensato come un array di array unidimensionali.

Il nostro multiDimensionalArr in memoria sarebbe simile a:

Chiaramente, multiDimensionalArr [0] contiene un riferimento a un array unidimensionale di dimensione 2, multiDimensionalArr [1] contiene un riferimento a un altro array unidimensionale di dimensione 3 e così via.

In questo modo Java ci consente di definire e utilizzare array multidimensionali.

4. Iterazione sugli elementi

Possiamo iterare un array multidimensionale proprio come qualsiasi altro array in Java.

Proviamo a iterare e inizializzare gli elementi multiDimensionalArr utilizzando gli input dell'utente:

void initializeElements(int[][] multiDimensionalArr) { Scanner sc = new Scanner(System.in); for (int outer = 0; outer < multiDimensionalArr.length; outer++) { for (int inner = 0; inner < multiDimensionalArr[outer].length; inner++) { multiDimensionalArr[outer][inner] = sc.nextInt(); } } }

In questo caso, multiDimensionalArr [esterno] .length è la lunghezza di un array in corrispondenza di un indice esterno in multiDimensionalArr .

Ci aiuta a garantire che stiamo cercando elementi solo all'interno di un intervallo valido di ciascun sotto-array , evitando così un'eccezione ArrayIndexOutOfBoundException .

5. Elementi di stampa

E se volessimo stampare gli elementi del nostro array multidimensionale?

Un modo ovvio sarebbe usare la logica di iterazione che abbiamo già trattato. Ciò comporta l'iterazione di ogni elemento all'interno del nostro array multidimensionale, che a sua volta è un array, e quindi l'iterazione su quell'array figlio - un elemento alla volta.

Un'altra opzione che abbiamo è usare il metodo di supporto java.util.Arrays.toString () :

void printElements(int[][] multiDimensionalArr) { for (int index = 0; index < multiDimensionalArr.length; index++) { System.out.println(Arrays.toString(multiDimensionalArr[index])); } }

E finiamo per avere un codice pulito e semplice. L'output della console generato sarebbe simile a:

[1, 2] [3, 4, 5] [6, 7, 8, 9]

6. Lunghezza degli elementi

Possiamo trovare la lunghezza degli array in un array multidimensionale iterando sull'array principale:

int[] findLengthOfElements(int[][] multiDimensionalArray) { int[] arrayOfLengths = new int[multiDimensionalArray.length]; for (int i = 0; i < multiDimensionalArray.length; i++) { arrayOfLengths[i] = multiDimensionalArray[i].length; } return arrayOfLengths; }

Possiamo anche trovare la lunghezza degli array utilizzando i flussi Java:

Integer[] findLengthOfArrays(int[][] multiDimensionalArray) { return Arrays.stream(multiDimensionalArray) .map(array -> array.length) .toArray(Integer[]::new); }

7. Copiare un array 2-D

Possiamo copiare un array 2-D usando il metodo Arrays.copyOf :

int[][] copy2DArray(int[][] arrayOfArrays) { int[][] copied2DArray = new int[arrayOfArrays.length][]; for (int i = 0; i < arrayOfArrays.length; i++) { int[] array = arrayOfArrays[i]; copied2DArray[i] = Arrays.copyOf(array, array.length); } return copied2DArray; }

Possiamo anche ottenere questo risultato utilizzando i flussi Java:

Integer[][] copy2DArray(Integer[][] arrayOfArrays) { return Arrays.stream(arrayOfArrays) .map(array -> Arrays.copyOf(array, array.length)) .toArray(Integer[][]::new); }

8. Conclusione

In questo articolo, abbiamo esaminato cosa sono gli array multidimensionali, come appaiono in memoria e come possiamo definirli e usarli.

Come sempre, il codice sorgente degli esempi presentati può essere trovato su GitHub.