array frastagliati in java

1. Array frastagliati

Come programmatore Java non solo puoi scambiare le righe di un array bidimensionale, ma anche costruire un array come preferisci.

Diciamo che vuoi che la prima riga di un array bidimensionale abbia una lunghezza di 10, e vuoi che la lunghezza della seconda riga sia 50. Possiamo farlo? Sì possiamo.

Innanzitutto, dobbiamo creare un "contenitore di contenitori": questo è il primo array, che memorizzerà i riferimenti agli array di righe. Ecco come è fatto:

int[][] name = new int[height][];

Ometti semplicemente la seconda dimensione e la macchina Java crea un contenitore di contenitori. Questo è ciò che sarà in memoria dopo aver eseguito questo codice:

E, beh, sai già come creare array unidimensionali 🙂

Ecco come apparirà il codice risultante:

// Matrix of important data
int[][] matrix = new int[2][];
matrix[0] = new int[10];
matrix[1] = new int[50]

Abbiamo appena creato un cosiddetto " array frastagliato ".

E se ora vogliamo visualizzare sullo schermo tutti gli elementi di questo array, allora la lengthproprietà dell'array tornerà utile: dopotutto, le lunghezze delle righe dell'array sono diverse.

A proposito, come trovi la lunghezza di un "contenitore di contenitori" nel nostro esempio? È anche un oggetto array, il che significa che ha una lunghezza. La risposta corretta è matrix.length.

Che ne dici degli array che compongono le nostre righe?matrix[0].length

2. Lavorare con un array bidimensionale

Supponiamo di voler visualizzare un array bidimensionale. Come si fa a farlo?

Il nostro codice sarà simile a questo:

int[][] matrix = new int[3][];
matrix[0] = new int[]{1, 2, 3, 4, 5, 6};
matrix[1] = new int[]{1, 2, 3};
matrix[2] = new int[]{1};
for (int i = 0; i < matrix.length; i++) {
   for (int j = 0; j < matrix[i].length; j++)
      System.out.print( matrix[i][j] + " " );
   System.out.println();
}

Hai bisogno di due cicli nidificati. Il primo lo chiamiamo esterno e il secondo interno .

Nel ciclo esterno (la ivariabile), passiamo in sequenza attraverso tutte le righe (array) che compongono il nostro array bidimensionale. Ogni valore di icorrisponde a una riga con quell'indice.

Nel ciclo interno (la jvariabile), iteriamo su tutte le celle nelle righe. Grazie al ciclo interno, sullo schermo verrà visualizzata una riga, che consiste nei valori di un array unidimensionale.

Questo è ciò che verrà visualizzato:

1 2 3 4 5 6

1 2 3 4 5 6
1 2 3

1 2 3 4 5 6
1 2 3
1

3. Array multidimensionali

Un altro fatto interessante sugli array, uno che probabilmente hai già indovinato. Se puoi creare un array bidimensionale, allora puoi creare un array tridimensionale?

Sì, puoi creare un array di qualsiasi dimensione. Tali array sono chiamati "multidimensionali".

Solo per divertimento, creiamo un array multidimensionale con 4 dimensioni.

int[][][][] matrix = new int[2][3][4][5];

Questo codice è troppo semplice, vero?

E se lo crei manualmente?

int[][][][] matrix;
matrix = new int[2][][][];                // Create a 2-element array of references to references to references
for (int i = 0; i < matrix.length; i++)
{
  matrix[i] = new int[3][][];                // Create a 3-element array of references to references
  for (j = 0; j < matrix[i].length; j++)
  {
    matrix[i][j] = new int[4][];             // Create a 4-element array of references
    for (k = 0; k < matrix[i][j].length; k++)
      matrix[i][j][k] = new int[5];          // Create 5-element arrays of integers
  }
}

E questo sta solo creando l'array! Quindi devi anche lavorarci in qualche modo.

Compito bonus: scrivere codice che visualizzi tutti i valori in un array tridimensionale.