Syntaxe de création d'un tableau à deux dimensions

Considérer:

int[][] multD = new int[5][];
multD[0] = new int[10];

Est-ce ainsi que vous créez un tableau à deux dimensions avec 5 lignes et 10 colonnes?

J'ai vu ce code en ligne, mais la syntaxe n'avait pas de sens.

Essayez ce qui suit:

int[][] multi = new int[5][10];

... qui est une main courte pour quelque chose comme ça:

int[][] multi = new int[5][];
multi[0] = new int[10];
multi[1] = new int[10];
multi[2] = new int[10];
multi[3] = new int[10];
multi[4] = new int[10];

Notez que chaque élément sera initialisé à la valeur par défaut int, 0, donc ci - dessus sont également équivalent à:

int[][] multi = new int[][]{
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};

Nous pouvons déclarer un tableau à deux dimensions et stocker directement les éléments au moment de sa déclaration comme:

int marks[][]={{50,60,55,67,70},{62,65,70,70,81},{72,66,77,80,69}};

Ici, int représente des éléments de type entier stockés dans le tableau et le nom du tableau est «marques». int est le type de données pour tous les éléments représentés à l'intérieur des accolades "{" et "}" car un tableau est une collection d'éléments ayant le même type de données.

Pour en revenir à notre déclaration écrite ci-dessus: chaque ligne d'éléments doit être écrite à l'intérieur des accolades. Les lignes et les éléments de chaque ligne doivent être séparés par des virgules.

Observez maintenant la déclaration: vous pouvez obtenir 3 lignes et 5 colonnes, de sorte que la JVM crée 3 * 5 = 15 blocs de mémoire. Ces blocs peuvent être appelés individuellement:

marks[0][0]  marks[0][1]  marks[0][2]  marks[0][3]  marks[0][4]
marks[1][0]  marks[1][1]  marks[1][2]  marks[1][3]  marks[1][4]
marks[2][0]  marks[2][1]  marks[2][2]  marks[2][3]  marks[2][4]

REMARQUE:
si vous souhaitez stocker n éléments, l'index du tableau commence à zéro et se termine à n-1 . Une autre façon de créer un tableau bidimensionnel consiste à déclarer d'abord le tableau, puis à lui allouer de la mémoire à l'aide d'un nouvel opérateur.

int marks[][];           // declare marks array
marks = new int[3][5];   // allocate memory for storing 15 elements

En combinant les deux ci-dessus, nous pouvons écrire:

int marks[][] = new int[3][5];

Vous pouvez les créer exactement comme d'autres l'ont mentionné. Un dernier point à ajouter: vous pouvez même créer un tableau bidimensionnel asymétrique avec chaque ligne, sans nécessairement avoir le même nombre de colonnes, comme ceci:

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

L'idiome le plus courant pour créer un tableau à deux dimensions avec 5 lignes et 10 colonnes est:

int[][] multD = new int[5][10];

_{Alternativement, vous pouvez utiliser ce qui suit, qui est plus similaire à ce que vous avez, mais vous devez initialiser explicitement chaque ligne:}

int[][] multD = new int[5][];
for (int i = 0; i < 5; i++) {
  multD[i] = new int[10];
}

Il est également possible de le déclarer de la manière suivante. Ce n'est pas un bon design, mais ça marche.

int[] twoDimIntArray[] = new int[5][10];

Essayer:

int[][] multD = new int[5][10];

Notez que dans votre code, seule la première ligne du tableau 2D est initialisée à 0. Les lignes 2 à 5 n'existent même pas. Si vous essayez de les imprimer, vous obtiendrez nullpour chacun d'eux.

int [][] twoDim = new int [5][5];

int a = (twoDim.length);//5
int b = (twoDim[0].length);//5

for(int i = 0; i < a; i++){ // 1 2 3 4 5
    for(int j = 0; j <b; j++) { // 1 2 3 4 5
        int x = (i+1)*(j+1);
        twoDim[i][j] = x;
        if (x<10) {
            System.out.print(" " + x + " ");
        } else {
            System.out.print(x + " ");
        }
    }//end of for J
    System.out.println();
}//end of for i

En Java, un tableau bidimensionnel peut être déclaré identique à un tableau unidimensionnel. Dans un tableau unidimensionnel, vous pouvez écrire comme

  int array[] = new int[5];

où int est un type de données, array [] est une déclaration de tableau et new arrayest un tableau avec ses objets avec cinq index.

Comme ça, vous pouvez écrire un tableau à deux dimensions comme suit.

  int array[][];
  array = new int[3][4];

Voici arrayun type de données int. J'ai tout d'abord déclaré sur un tableau unidimensionnel de ce type, puis un tableau à 3 lignes et 4 colonnes est créé.

Dans votre code

int[][] multD = new int[5][];
multD[0] = new int[10];

signifie que vous avez créé un tableau à deux dimensions, avec cinq lignes. Dans la première ligne, il y a 10 colonnes. En Java, vous pouvez sélectionner la taille de colonne pour chaque ligne comme vous le souhaitez.

int rows = 5;
int cols = 10;

int[] multD = new int[rows * cols];

for (int r = 0; r < rows; r++)
{
  for (int c = 0; c < cols; c++)
  {
     int index = r * cols + c;
     multD[index] = index * 2;
  }
}

Prendre plaisir!

Essayez de cette façon:

int a[][] = {{1,2}, {3,4}};

int b[] = {1, 2, 3, 4};

Ces types de tableaux sont connus sous le nom de tableaux dentelés en Java:

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

Dans ce scénario, chaque ligne du tableau contient le nombre différent de colonnes. Dans l'exemple ci-dessus, la première ligne contiendra trois colonnes, la deuxième ligne contiendra deux colonnes et la troisième ligne contiendra cinq colonnes. Vous pouvez initialiser ce tableau au moment de la compilation comme ci-dessous:

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

Vous pouvez facilement parcourir tous les éléments de votre tableau:

for (int i = 0; i<multD.length; i++) {
    for (int j = 0; j<multD[i].length; j++) {
        System.out.print(multD[i][j] + "\t");
    }
    System.out.println();
}

En fait, Java n'a pas de tableau multidimensionnel au sens mathématique. Ce que Java a, c'est juste un tableau de tableaux, un tableau où chaque élément est également un tableau. C'est pourquoi l'exigence absolue de l'initialiser est la taille de la première dimension. Si le reste est spécifié, il créera un tableau rempli avec la valeur par défaut.

int[][]   ar  = new int[2][];
int[][][] ar  = new int[2][][];
int[][]   ar  = new int[2][2]; // 2x2 array with zeros

Cela nous donne également une bizarrerie. La taille du sous-tableau ne peut pas être modifiée en ajoutant plus d'éléments, mais nous pouvons le faire en attribuant un nouveau tableau de taille arbitraire.

int[][]   ar  = new int[2][2];
ar[1][3] = 10; // index out of bound
ar[1]    = new int[] {1,2,3,4,5,6}; // works