array multidimensionali in Java e C #

Question

In C # ci sono 2 modi per creare array mutlidimensional.

int[,] array1 = new int[32,32];

int[][] array2 = new int[32][];
for(int i=0;i<32;i++) array2[i] = new int[32];

So che il primo metodo crea una matrice 1-dimensionale internamente, e che il secondo metodo crea un array di array (accesso lento).

Tuttavia in Java, non esiste una cosa come [,], e vedo gli array multidimensionali dichiarate in questo modo:

int[][] array3 = new int[32][32];

Poiché tale sintassi è illegale in C # e Java non ha int[,], mi chiedo se questo è l'equivalente di array1? O è ancora un array di array?

Answer 1

Sei scorretto; frastagliati (annidati) array sono più veloci. (Il CLR è ottimizzato per loro)

Java non supporta veri array multidimensionali; che è una matrice irregolare.
La sintassi di Java crea automaticamente tutte le matrici interne; in C #, che avrebbe bisogno di un ciclo separato.

Answer 2

E 'ancora un array di array. E 'solo che in C # che avrebbe dovuto creare ogni sottoarray in un ciclo. Quindi questo Java:

// Java
int[][] array3 = new int[32][32];

è equivalente a questo C #:

// C#
int[][] array3 = new int[32][];
for (int i = 0; i < array3.Length; i++)
{
    array3[i] = new int[32];
}

(Come Slaks dice, gli array frastagliati sono generalmente più veloci in .NET di array rettangolari. Sono meno efficiente in termini di memoria, però.)

Answer 3

Perché le persone erano preoccupati per le prestazioni di multi-dimensione vs array sfalsati in .NET, ho realizzato alcuni test e benchmark i risultati sul 8k da 8k elementi:

I test sono stati:

1. array 2D multidimensionale
2. Multi-dimensionale con indici all'indietro (y prima)
3. Multi-dimensionale con GetLength (x) invece di interi vincolato
4. sfalsati indietro indicies
5. sfalsati
6. Un dimensionale (dimensione x dimensione) con moltiplicazione dell'indice
7. Una dimensionale con indice di incremento

E i risultati:

one <> Elapsed Time: 0.543558s
two <> Elapsed Time: 0.8911516s
three <> Elapsed Time: 0.8908123s
four <> Elapsed Time: 1.1367238s
five <> Elapsed Time: 0.3039648s
six <> Elapsed Time: 0.8110969s
seven <> Elapsed Time: 0.2629394s

Per divertimento li riceve l'emulatore WP7 pure, e ottenuto numeri simili.

Codice della funzione di test è qui .

Answer 4

In Java si sta dichiarando un array di array.

È possibile vedere questo dal seguente codice:

int[][] arrOfArr = new int[5][];
arrOfArr[0] = new int[5];
arrOfArr[1] = new int[1];
arrOfArr[2] = new int[9];
...

int[][] arr = new int[3][3]; è solo una scorciatoia per:

int[][] arr = new int[3][];
arr[0] = new int[3];
arr[1] = new int[3];
arr[2] = new int[3];

Answer 5

stavo traducendo po 'di codice Java in C # - Ecco come ho fatto la matrice irregolare

    //Java
    private static int grad3[][] = {{1,1,0},{-1,1,0},{1,-1,0},{-1,-1,0},{1,0,1},{-1,0,1},{1,0,-1},{-1,0,-1},{0,1,1},{0,-1,1},{0,1,-1},{0,-1,-1}};

    //C#
    private static int[,] grad3setup = { { 1, 1, 0 }, { -1, 1, 0 }, { 1, -1, 0 }, { -1, -1, 0 }, { 1, 0, 1 }, { -1, 0, 1 }, { 1, 0, -1 }, { -1, 0, -1 }, 
                                  { 0, 1, 1 }, { 0, -1, 1 }, { 0, 1, -1 }, { 0, -1, -1 } };

    private static int[][] grad3
    {
        get
        {
            int[][] grad3 = new int[12][];
            for (int i = 0; i < grad3.Length; i++)
            {
                grad3[i] = new int[3] { grad3setup[i, 0], grad3setup[i, 1], grad3setup[i, 2] };
            }
            return grad3;
        }
    }

Answer 6

È un array di array con le stesse prestazioni compromessi come in C #. Se sapete che il vostro array di array non sta per essere frastagliata, allora si può avvolgerlo in una classe per ottenere 2-d indicizzazione su un 1-d matrice di supporto.