Java: un array bidimensionale è memorizzato in ordine di colonna maggiore o maggiore di riga?

In Java, una matrice multidimensionale è archiviata in ordine di colonna principale o principale?

Java non ha matrici multidimensionali. Ha matrici di array. Quindi, ad esempio,

int[][] 

… è un array di int[] (e ovviamente int[] è un array di int ).

Di conseguenza, Java non è né la colonna principale né l’ordine di riga maggiore (ma vedi la nota sotto su come leggere a[2][3] ), perché mentre le voci di un determinato array sono memorizzate in un blocco contiguo di memoria, gli array subordinati le voci puntate sono riferimenti di oggetti a blocchi di memoria completamente separati, non correlati. Ciò significa anche che le matrici di array di Java sono intrinsecamente seghettate : la voce a [0] potrebbe riferirsi a un array a 3 slot, quella a [1] potrebbe riferirsi a un array a 4 slot, [2] potrebbe non riferirsi a un array a tutti (potrebbe avere null ), e forse [3] riferisce ad un array a 6 slot.

Un’immagine vale 1k-24 parole e tutto questo:

                          + -------- +
                    + ----> |  int [] |
 + ----------- + |  + -------- +
 |  int [] [] |  |  |  0: int |
 + ----------- + |  |  1: int |
 |  0: int [] | ------ + |  2: int |
 |  1: int [] | ------ + + -------- +
 |  2: null |  |
 |  3: int [] | - + |  + -------- +
 + ----------- + |  + ----> |  int [] |
                |  + -------- +
                |  |  0: int |
                |  |  1: int |
                |  |  2: int |
                |  |  3: int |
                |  + -------- +
                |
                |  + -------- +
                + --------- |  int [] |
                          + -------- +
                          |  0: int |
                          |  1: int |
                          |  2: int |
                          |  3: int |
                          |  4: int |
                          |  5: int |
                          + -------- +

Una volta che lo sai, sai che (diciamo) a[2][3] significa “Ottieni l’array a cui fa riferimento la voce all’indice 2 di a , quindi ottieni la voce a cui fa riferimento l’indice 3 di quell’array subordinato.” Penso che sia abbastanza simile all’ordine row-major, ma non è esattamente la stessa cosa.

In Java, hai solo un array dimensionale.

Gli array 2D sono fondamentalmente solo array unidimensionali di array monodesmensionali.

 int[ ][ ] table; table = new int[3][ ]; table[0] = new int[5]; table[1] = new int[5]; table[2] = new int[5]; 

Nessuno dei due. Una matrice bidimensionale in Java è una matrice di riferimenti agli array. Non è memorizzato linearmente in memoria.