multidimensional arrays java 2d
Ce didacticiel sur les tableaux multidimensionnels en Java explique comment initialiser, accéder et imprimer des tableaux 2D et 3D en Java avec des exemples de syntaxe et de code:
Jusqu'à présent, nous avons discuté des principaux concepts concernant les tableaux unidimensionnels. Ces tableaux stockent une seule séquence ou liste d'éléments du même type de données.
Java prend également en charge les tableaux avec plusieurs dimensions et ceux-ci sont appelés tableaux multidimensionnels.
=> Consultez TOUS les didacticiels Java ici.
Les tableaux multidimensionnels Java sont agencés comme un tableau de tableaux, c'est-à-dire que chaque élément d'un tableau multidimensionnel est un autre tableau. La représentation des éléments est en lignes et en colonnes. Ainsi, vous pouvez obtenir un nombre total d'éléments dans un tableau multidimensionnel en multipliant la taille de la ligne par la taille de la colonne.
Donc, si vous avez un tableau à deux dimensions de 3 × 4, alors le nombre total d'éléments dans ce tableau = 3 × 4 = 12.
Dans ce didacticiel, nous explorerons les tableaux multidimensionnels en Java. Voyons d'abord les tableaux à deux dimensions avant de passer à des tableaux à trois dimensions ou plus.
Ce que vous apprendrez:
- Réseau bidimensionnel
- Tableaux multidimensionnels Java
- Tableaux tridimensionnels en Java
- Questions fréquemment posées
- Conclusion
Réseau bidimensionnel
Le plus simple du tableau multidimensionnel est un tableau bidimensionnel. Une définition simple des tableaux 2D est: Un tableau 2D est un tableau de tableaux à une dimension.
En Java, un tableau à deux dimensions est stocké sous forme de lignes et de colonnes et est représenté sous la forme d'une matrice.
La déclaration générale d'un tableau à deux dimensions est,
data_type [] [] array_name;
Ici,
data_type = type de données des éléments qui seront stockés dans un tableau.
array_name = nom du tableau à deux dimensions.
Vous pouvez créer un tableau 2D en utilisant new comme suit:
data_type [] [] array_name = new data_type[row_size][column_size];
Ici,
row_size = nombre de lignes qu'un tableau contiendra.
column_size = nombre de colonnes que le tableau contiendra.
Donc, si vous avez un tableau de 3 × 3, cela signifie qu'il aura 3 lignes et 3 colonnes.
La disposition de ce tableau sera comme indiqué ci-dessous.
Rangées colonnes | Colonne1 | Colonne2 | Colonne3 |
---|---|---|---|
Row1 | [0,0] | [0,1] | [0,2] |
Row2 | [1.0] | [1,1] | [1,2] |
Row3 | [2.0] | [2.1] | [2.2] |
Comme indiqué ci-dessus, chaque intersection de ligne et de colonne stocke un élément du tableau 2D. Donc, si vous voulez accéder au premier élément du tableau 2d, il est donné par [0, 0].
Remarque que comme la taille du tableau est 3 × 3, vous pouvez avoir 9 éléments dans ce tableau.
Un tableau d'entiers nommé «myarray» de 3 lignes et 2 colonnes peut être déclaré comme ci-dessous.
int [][] myarray = new int[3][2];
Une fois le tableau déclaré et créé, il est temps de l'initialiser avec des valeurs.
Initialiser 2d Array
Il existe différentes manières d'initialiser le tableau 2d avec des valeurs. La première méthode est la méthode traditionnelle d'attribution de valeurs à chaque élément.
La syntaxe générale pour l'initialisation est:
array_name[row_index][column_index] = value;
Exemple:
int[][] myarray = new int[2][2]; myarray[0][0] = 1; myarray[0][1] = myarray[1][0] = 0; myarray[1][1] = 1;
Les instructions ci-dessus initialisent tous les éléments du tableau 2d donné.
Mettons-le dans un programme et vérifions la sortie.
public class Main { public static void main(String[] args) { int[][] myarray = new int[2][2]; myarray[0][0] = 1; myarray[0][1] = myarray[1][0] = 0; myarray[1][1] = 1; System.out.println('Array elements are:'); System.out.println(myarray[0][0] + ' ' +myarray[0][1]); System.out.println(myarray[1][0] + ' ' +myarray[1][1]); } }
Production:
Cette méthode peut être utile lorsque les dimensions concernées sont plus petites. Au fur et à mesure que la dimension du tableau augmente, il est difficile d'utiliser cette méthode pour initialiser individuellement les éléments.
La méthode suivante pour initialiser le tableau 2d en Java consiste à initialiser le tableau au moment de la déclaration uniquement.
La syntaxe générale de cette méthode d'initialisation est la suivante:
meilleur site pour regarder des anime gratuitement
data_type[][] array_name = {{val_r1c1,val_r1c2,...val_r1cn}, {val_r2c1, val_r2c2,...val_r2cn}, … {val_rnc1, val_rnc2,…val_rncn}};
Par exemple, si vous avez un tableau 2 × 3 de type int, alors vous pouvez l'initialiser avec la déclaration comme:
int [][] intArray = {{1, 2, 3}, {4, 5, 6}};
L'exemple suivant montre la déclaration de tableau 2d avec l'initialisation.
public class Main { public static void main(String[] args) { //2-d array initialised with values int[][] intArray = { { 1, 2 }, { 3, 4 },{5,6}}; //print the array System.out.println('Initialized Two dimensional array:'); for (int i = 0; i <3; i++) { for (int j = 0; j < 2; j++) { System.out.print(intArray [i][j] + ' '); } System.out.println(); } } }
Production:
Dans le programme ci-dessus, le tableau est initialisé au moment de la déclaration proprement dite, puis les valeurs sont affichées.
Vous pouvez également initialiser ou affecter les valeurs au tableau 2d en utilisant une boucle comme indiqué ci-dessous.
int[][] intArray = new int[3][3]; for (int i = 0; i <3; i++) { for (int j = 0; j < 3; j++) { intArray[i][j] = i+1; } }
Le programme suivant implémente le code ci-dessus.
public class Main { public static void main(String[] args) { //declare an array of int int[][] intArray = new int[3][3]; System.out.println('Array elements are:'); for (int i = 0; i <3; i++) { for (int j = 0; j < 3; j++) { intArray[i][j] = i+1; //assign values to each array element System.out.print(intArray[i][j] + ' '); //print each element } System.out.println(); } } }
Production:
Chaque élément du tableau 2D ci-dessus se voit attribuer une valeur «i + 1». Cela fait que chaque élément d'une ligne du tableau contient la même valeur.
Accès et impression de la matrice 2D
Vous savez déjà que lors de l'initialisation du tableau 2d, vous pouvez initialiser les éléments individuels du tableau à une valeur. Cela se fait en utilisant l'index de ligne et l'index de colonne du tableau pour accéder à un élément particulier.
Comme pour l'initialisation, vous pouvez également accéder à la valeur de l'élément individuel et l'imprimer à l'utilisateur.
La syntaxe générale pour accéder à l'élément du tableau est:
data_typeval = array_name[row_index][column_index];
Où nom_tableau est le tableau auquel on accède et type_données est le même que le type de données du tableau.
Le programme suivant montre comment accéder et imprimer un élément individuel.
public class Main { public static void main(String[] args) { //two dimensional array definition int[][] intArray = {{1,2},{4,8}}; //Access individual element of array intval = intArray[0][1]; //print the element System.out.println('Accessed array value = ' + val); System.out.println('Contents of Array:' ); //print individual elements of array System.out.println(intArray[0][0] + ' ' + intArray[0][1]); System.out.println(intArray[1][0] + ' ' + intArray[1][1]); } }
Production:
De cette façon, vous pouvez facilement accéder et imprimer des éléments de tableau individuels à l'aide d'index de ligne et de colonne entre crochets ([]).
Vous pouvez imprimer le tableau entier à la fois dans un format tabulaire comme indiqué ci-dessus (également appelé formulaire matriciel) en utilisant la boucle for. Comme il s'agit d'un tableau à deux dimensions, vous devez avoir deux boucles pour cela. Une boucle pour parcourir les lignes, c'est-à-dire la boucle externe et la boucle interne pour traverser les colonnes.
téléchargement gratuit du meilleur logiciel de piratage informatique au monde
À tout instant donné (itération courante), l'élément particulier du tableau est donné par,
nom_tableau [i] [j];
Où «i» est la ligne actuelle et «j» est la colonne actuelle.
Le programme suivant montre l’impression d’un tableau 2D à l’aide d’une boucle «for».
public class Main { public static void main(String[] args) { //two dimensional array definition int[][] intArray = new int[3][3]; //printing the 2-d array System.out.println('The two-dimensional array:'); for (int i = 0; i <3; i++) { for (int j = 0; j < 3; j++) { intArray[i][j] = i*j; //assign value to each array element System.out.print(intArray [i][j] + ' '); } System.out.println(''); } } }
Production:
Dans le programme ci-dessus, le tableau 2d est initialisé, puis les éléments sont imprimés en utilisant deux boucles for. La boucle externe est utilisée pour garder une trace des lignes tandis que la boucle for interne est pour les colonnes.
Longueur du tableau Java 2D
Un tableau à deux dimensions est défini comme le tableau d'un tableau à une dimension. Ainsi, lorsque vous avez besoin de la longueur d'un tableau 2d, ce n'est pas aussi simple que dans un tableau unidimensionnel.
La propriété length pour un tableau à deux dimensions renvoie le nombre de lignes du tableau. Chaque ligne est un tableau unidimensionnel. Vous savez déjà que le tableau à deux dimensions se compose de lignes et de colonnes. La taille de la colonne peut varier pour chaque ligne.
Par conséquent, vous pouvez obtenir la taille de chaque ligne en itérant sur le nombre de lignes.
Le programme suivant donne la longueur du tableau (nombre de lignes) ainsi que la taille de chaque ligne.
public class Main { public static void main(String[] args) { //initialize 2-d array int[][] myArray = { { 1, 2, 3 }, { 4, 5 } }; System.out.println('length of array:' + myArray.length); //number of rows for(int i=0;i Production:
Un tableau à deux dimensions défini ci-dessus comporte deux lignes. Chaque ligne est un tableau unidimensionnel. Le premier tableau 1D a 3 éléments (3 colonnes) tandis que la deuxième ligne a 2 éléments.
Le programme Java suivant montre l'utilisation de la propriété length pour imprimer le tableau 2d.
public class Main { public static void main(String[] args) { //two dimensional array definition int[][] myarray = new int[3][3]; //printing the 2-d array System.out.println('The two-dimensional array:'); for (int i = 0; i Production:
Comme déjà mentionné, la boucle externe représente les lignes et la boucle for interne représente les colonnes.
Noter: La condition de fin dans les deux boucles utilise la propriété length, d'abord pour parcourir les lignes, puis les colonnes.
Tableaux multidimensionnels Java
Nous avons déjà vu des tableaux bidimensionnels. Java prend en charge les tableaux de plus de deux dimensions.
La syntaxe générale d'un tableau multidimensionnel est la suivante:
data_type [d1][d2]…[dn] array_name = new data_type[d1_size][d2_size]…[dn_size];
Ici,
d1, d2… dn = dimensions du tableau multidimensionnel
[d1_size] [d2_size]… [dn_size] = tailles respectives des dimensions
data_type = type de données des éléments du tableau
array_name = nom du tableau multidimensionnel
À titre d'exemple d'un autre tableau multidimensionnel autre que le tableau 2D, examinons les détails des tableaux en trois dimensions (3D).
Tableaux tridimensionnels en Java
Nous avons déjà discuté du fait qu'un tableau devient plus complexe à mesure que ses dimensions augmentent. Les tableaux tridimensionnels sont complexes pour les tableaux multidimensionnels. Un tridimensionnel peut être défini comme un tableau de tableaux bidimensionnels.
La définition générale d'un tableau en trois dimensions est donnée ci-dessous:
data_type [] [] [] array_name = new data_type [d1][d2][d3];
Ici,
d1, d2, d3 = tailles des dimensions
data_type = type de données des éléments du tableau
array_name = nom du tableau 3D
Exemple de définition de tableau 3D:
int [] [] [] intArray = new int[2][3][4];
La définition ci-dessus du tableau 3D peut être interprétée comme ayant 2 tables ou tableaux, 3 lignes et 4 colonnes totalisant jusqu'à 2x3x4 = 24 éléments.
Cela signifie que dans un tableau 3D, les trois dimensions sont interprétées comme:
- Le nombre de tables / tableaux: La première dimension indique le nombre de tables ou de tableaux qu'un tableau 3D aura.
- Le nombre de lignes: La deuxième dimension signifie le nombre total de lignes qu'un tableau aura.
- Le nombre de colonnes: La troisième dimension indique le nombre total de colonnes dans le tableau 3D.
Initialiser la matrice 3D
Les approches utilisées pour initialiser un tableau 3D sont les mêmes que celles utilisées pour initialiser des tableaux bidimensionnels.
Vous pouvez soit initialiser le tableau en attribuant des valeurs à des éléments individuels du tableau, soit initialiser le tableau lors de la déclaration.
L'exemple ci-dessous montre l'initialisation du tableau 3d lors de la déclaration.
public class Main { public static void main(String[] args) { //initialize 3-d array int[][][] intArray = { { { 1, 2, 3}, { 4, 5, 6 } , { 7, 8, 9 } } }; System.out.println ('3-d array is given below :'); //print the elements of array for (int i = 0; i <1; i++) for (int j = 0; j < 3; j++) for (int z = 0; z < 3; z++) System.out.println ('intArray [' + i + '][' + j + '][' + z + '] = ' + intArray [i][j][z]); } }
Production:
questions et réponses entretien sélénium pdf
Après avoir initialisé le tableau 3d lors de la déclaration, nous avons accédé aux éléments individuels du tableau et les avons imprimés.
Accès et impression de la matrice 3d
Encore une fois, l'impression et l'accès aux éléments de tableau dans un tableau tridimensionnel sont similaires à ceux des tableaux bidimensionnels.
Le programme ci-dessous utilise des boucles for pour accéder aux éléments du tableau et les imprimer sur la console.
public class Main { public static void main(String[] args) { //initialize 3-d array int[][][] myArray = { { { 1, 2, 3 }, { 4, 5, 6 } }, { { 1, 4, 9 }, { 16, 25, 36 } }, { { 1, 8, 27 }, { 64, 125, 216 } } }; System.out.println('3x2x3 array is given below:'); //print the 3-d array for (int i = 0; i <3; i++) { for (int j = 0; j < 2; j++) { for (int k = 0; k < 3; k++) { System.out.print(myArray[i][j][k] + ' '); } System.out.println(); } System.out.println(); } } }
Production:
Le programme ci-dessus affiche une représentation tabulaire d'un tableau en trois dimensions. Comme indiqué, il s'agit d'un tableau 3x2x3 ce qui signifie qu'il comporte 3 tableaux, 2 lignes et 3 colonnes et donc 18 éléments.
Il est déjà mentionné que la taille de la colonne peut varier dans un tableau multidimensionnel. L'exemple ci-dessous illustre un tableau en trois dimensions avec des tailles de colonne variées.
Ce programme utilise également une boucle for améliorée pour parcourir le tableau et afficher ses éléments.
public class Main { public static void main(String[] args) { //initialize 3-d array int[][][] intArray = { {{10, 20, 30},{20, 40, 60}}, { {10, 30,50,70},{50},{80, 90}} }; System.out.println('Multidimensional Array (3-d) is as follows:'); // use for..each loop to iterate through elements of 3d array for (int[][] array_2D: intArray) { for (int[] array_1D: array_2D) { for(intelem: array_1D) { System.out.print(elem + ' '); } System.out.println(); } System.out.println(); } } }
Production:
Le tableau d'entrée utilisé est un tableau en trois dimensions avec une longueur de colonnes variée. L'amélioré pour chaque boucle utilisée pour chaque dimension affiche le contenu du tableau dans un format tabulaire.
Questions fréquemment posées
Q # 1) Qu'entendez-vous par tableau bidimensionnel?
Répondre: Un tableau bidimensionnel est appelé un tableau de tableaux et est généralement organisé sous la forme de matrices composées de lignes et de colonnes. Un tableau bidimensionnel trouve son utilisation principalement dans des bases de données relationnelles ou des structures de données similaires.
Q # 2) Qu'est-ce qu'un tableau unidimensionnel en Java?
Répondre: Un tableau unidimensionnel en Java est un tableau avec un seul index. Il s'agit de la forme la plus simple de tableaux en Java.
Q # 3) Quelle est la différence entre un tableau à une dimension et un tableau à deux dimensions?
Répondre: Le tableau unidimensionnel stocke une seule séquence d'éléments et n'a qu'un seul index. Un tableau à deux dimensions stocke un tableau de tableaux d'éléments et utilise deux indices pour accéder à ses éléments.
Q # 4) Que signifie être bidimensionnel?
Répondre: Deux dimensions signifie avoir seulement deux dimensions. Dans un monde géométrique, les objets qui n'ont que hauteur et largeur sont des objets bidimensionnels ou 2D. Ces objets n'ont ni épaisseur ni profondeur.
Les triangles, rectangles, etc. sont des objets 2D. En termes logiciels, bidimensionnel signifie toujours avoir deux dimensions et nous définissons généralement des structures de données comme des tableaux qui peuvent avoir 1, 2 ou plus de dimensions.
Q # 5) Lequel vient en premier dans un tableau - Lignes ou colonnes?
Répondre: Les tableaux bidimensionnels sont représentés sous forme de matrices et les matrices sont généralement écrites en termes de lignes x colonnes. Par exemple, une matrice de taille 2 × 3 aura 2 lignes et 3 colonnes. Par conséquent, pour le tableau 2D également, les lignes viennent en premier et les colonnes ensuite.
Conclusion
Il s'agissait de tableaux multidimensionnels en Java. Nous avons discuté de tous les aspects des tableaux à deux dimensions ainsi que d'un tableau avec plus de deux dimensions.
Celles-ci sont généralement appelées tableau ou tableaux car, dans le cas de tableaux multidimensionnels, chaque élément est un autre tableau. Ainsi, on peut dire qu'un tableau contient un autre tableau ou simplement un tableau de tableaux.
Dans nos prochains tutoriels, nous explorerons plus en détail les tableaux, puis passerons à d'autres collections.
=> Regardez la série de formation Java simple ici.
lecture recommandée
- Java Array - Comment imprimer des éléments d'un tableau en Java?
- Java Generic Array - Comment simuler des tableaux génériques en Java?
- Tableaux multidimensionnels et tableaux dentelés en C #
- Introduction aux tableaux Java et aux concepts associés
- Tableaux multidimensionnels en C ++
- Types de données Java, boucles, tableaux, commutateurs et assertions
- Java Array - Déclarer, créer et initialiser un tableau en Java
- Tutoriel Java Array Length avec des exemples de code