Java

Les tableaux en Java

Un tableau est une liste nommée d'éléments de données qui ont tous le même type de données. Chaque donnée est un élément du tableau.

Tableaux à une dimension (1D)

Déclaration d'un tableau

Vous déclarez un tableau de la même manière que vous déclarez une variable simple, mais vous insérez une paire de crochets après le type de données.

Syntaxe :
                                typeDonnee[] nomTableau;   // la manière préférée.
                                ou
                                typeDonnee nomTableau[];  // fonctionne, mais c'est pas la manière préférée.
                            
Exemple 1 :
                                double[] tab;
                                Etudiant[] etds;
                            

Vous pouvez fournir n'importe quel identifiant légal pour un tableau, mais les programmeurs Java nomment généralement les tableaux en suivant les mêmes règles que celles utilisées pour les variables. Les noms de tableau commencent par une lettre minuscule et utilisent des lettres majuscules pour commencer les mots suivants.

Exemple 2 :
                                Etudiant[] listeEtudiants;
                            

Création d'un tableau

Après avoir créé une variable tableau, vous devez réserver de l'espace mémoire.

Déclarer un tableau et lui réserver de la mémoire sont deux processus distincts. Pour réserver des emplacements mémoire pour 20 valeurs "Etudiant", vous pouvez déclarer la variable de tableau et créer le tableau avec deux instructions distinctes, comme suit:

Exemple 3 :
                                Etudiant[] listeEtudiants;
                                listeEtudiants = new Etudiant[20];
                            

Vous pouvez également déclarer et créer un tableau dans une seule instruction ,comme suit :

Exemple 4 :
                                Etudiant[] listeEtudiants = new Etudiant[20];
                            
 Remarque !  En Java, la taille d'un tableau suit le type de données et n'est jamais déclarée immédiatement après le nom du tableau, comme c'est le cas dans d'autres langages tels que C ++.
En utilisant des crochets, les créateurs de Java vous ont facilité la distinction entre les noms de tableaux et les méthodes.

Un indice est un entier contenu entre crochets qui spécifie un des éléments d’un tableau. En Java, tous les éléments d’un tableau sont numérotés en commençant par 0. Vous pouvez donc utiliser légalement tout indice compris entre 0 et 19 lorsque vous travaillez avec un tableau comportant 20 éléments.

 Remarque !  Un indice s'appelle également un index. En particulier, vous verrez le terme index dans certains messages d'erreur émis par le compilateur.

C'est une erreur courante d'oublier que le premier élément d'un tableau est l'élément 0, en particulier si vous connaissez un autre langage de programmation dans lequel le premier élément de tableau est l'élément 1 tel que Scilab. Faire cette erreur signifie que vous serez "décalé d'un" dans votre utilisation d'un tableau.

Il est également courant d’oublier que l’indice du dernier élément est inférieur à la taille du tableau. Par exemple, l'indice le plus élevé autorisé pour un tableau de 100 éléments est 99.

Pour se rappeler que les éléments de tableau commencent par l'élément 0, cela peut être utile si vous pensez que le premier élément de tableau est à «zéro élément du début du tableau». , le deuxième élément étant «un élément à l’écart» du début du tableau, et ainsi de suite.

Si vous utilisez un indice trop petit (c'est-à-dire négatif) ou trop grand pour un tableau, il est hors limites (out of bounds) et un message d'erreur est généré.

Lorsque vous déclarez ou accédez à un tableau, vous pouvez utiliser n'importe quelle expression pour représenter la taille, à condition que l'expression soit un entier. Certains autres langages de programmation, tels que C ++, n'autorisent que l'utilisation de constantes nommées ou non nommées pour la taille lorsqu'un tableau est déclaré. Java permet aux variables, aux expressions arithmétiques et aux valeurs de retour de méthode d'être utilisées comme tailles de tableau, ce qui rend la déclaration de tableau plus flexible.

Exemple 5 :
                                // Une constante entière littérale;
                                double[] tarifs = new double[10];

                                // Une constante entière nommée (MAX_ELEM)
                                double[] tarifs = new double[MAX_ELEM]; 

                                // Une variable entière
                                double[] tarifs = new double[nombre];
                            

Initialiser un tableau

Une variable de type primitif, telle que int, contient une valeur. Une variable de type référence, telle qu'un tableau, contient une adresse mémoire dans laquelle une valeur est stockée. En d'autres termes, les noms de tableau contiennent des références, comme tous les noms d'objet Java.

Aucune adresse de mémoire n'est attribuée lorsque vous déclarez un tableau en utilisant uniquement un type de données, des crochets et un nom. Au lieu de cela, le nom de la variable de tableau a la valeur null, ce qui signifie que l'identificateur n'est pas associé à une adresse de mémoire.

Lorsque vous utilisez le mot-clé new pour définir un tableau, la référence de tableau acquiert une valeur d'adresse de mémoire.

Exemple 6 :
                                int[] nums = new int[10];
                            

nums contient une adresse, mais chaque élément de nums a la valeur 0 par défaut, car nums est un tableau d'entiers. Les valeurs par défaut suivantes sont utilisées pour différents types de tableaux:

  •  0 est attribué à chaque élément d'un tableau int.
  •  Chaque élément d'un tableau double ou float est attribué 0.0.
  •   Chaque élément d'un tableau de caractères est attribué à \u0000, qui correspond à la valeur Unicode d'un caractère null.
  •  La valeur false est attribuée à chaque élément d'un tableau booléen.
  •   Chaque élément d'un tableau d'objets, y compris String, est affecté de la valeur null par défaut.

Lorsque vous travaillez avec un élément individuel de tableau , vous ne le traitez pas différemment de la façon dont vous traiteriez une variable unique du même type. Par exemple, pour affecter une valeur au premier élément nums d'un tableau, utilisez une instruction d'affectation simple, telle que la suivante:

Exemple 7 :
                                nums[0] = 4;// premier élément
                            

Vous pouvez également affecter des valeurs non définies par défaut aux éléments du tableau lors de la création. Pour initialiser un tableau, vous utilisez une liste de valeurs d'initialisation séparées par des virgules et placées entre des accolades.

Exemple 8 :
                                int[] nums = {2, 5, 3, 7, 7, 6, 8, 9, 10, 13};
                            

Lorsque vous remplissez un tableau lors de sa création en fournissant une liste d'initialisation, vous ne lui attribuez pas de taille. La taille est attribuée en fonction du nombre de valeurs que vous placez dans la liste d'initialisation. Par exemple, le tableau nums que vous venez de définir a une taille de 10. En outre, lorsque vous initialisez un tableau, vous n'avez pas besoin d'utiliser le mot clé new; à la place, la nouvelle mémoire est attribuée en fonction de la longueur de la liste des valeurs fournies.

  En Java, vous ne pouvez pas directement initialiser une partie d'un tableau. Par exemple, vous ne pouvez pas créer un tableau de 10 éléments et n'en initialiser que 5; vous devez soit initialiser chaque élément, soit ne rien initialiser.

Utiliser des indices variables avec un tableau

le champ length contient le nombre d'éléments dans le tableau.

Lors du traitement des éléments d'un tableau, nous utilisons souvent une boucle for ou une boucle foreach car tous les éléments d'un tableau sont du même type et que la taille du tableau est connue.

Exemple 9 : boucle for
                                    public class Test {
                                        public static void main(String args[]) {
                                            int[] nums = { 3, 5, 6, 8, 6, 7, 18, 19 };
                                    
                                            // afficher les éléments du tableau
                                            for (int i = 0; i < nums.length; i++) {
                                                System.out.println("Element " + i + " : " + nums[i]);
                                            }
                                    
                                        }
                                    }
                            
Element 0 : 3
Element 1 : 5
Element 2 : 6
Element 3 : 8
Element 4 : 6
Element 5 : 7
Element 6 : 18
Element 7 : 19
Exemple 10 : boucle foreach
                                    public class Test {
                                        public static void main(String args[]) {
                                            double[] nums = { 3.6, 5.0, 6, 8, 6, 7.76, 18, 19.5 };
                                    
                                            // afficher les éléments du tableau
                                            for (double elem : nums) {
                                                System.out.println(elem);
                                            }
                                    
                                        }
                                    }
                            
3.6
5.0
6.0
8.0
6.0
7.76
18.0
19.5

Passer des tableaux à des méthodes

Tout comme vous pouvez transmettre des valeurs de type primitif à des méthodes, vous pouvez également transmettre des tableaux à des méthodes. Par exemple, la méthode suivante affiche les éléments dans un tableau int

Exemple 11 :
                                    public class Test {
                                        public void affiche(int[] tab) {
                                            // afficher les éléments du tableau
                                            for (double elem : tab) {
                                                System.out.println(elem);
                                            }
                                        }
                                    
                                        public static void main(String args[]) {
                                            int[] nums = { 3, 5, 6, 8, 6, 7, 18 };
                                    
                                            Test t = new Test();
                                            t.affiche(nums);
                                        }
                                    }
                            
3.0
5.0
6.0
8.0
6.0
7.0
18.0

Retourner un tableau à partir d'une méthode

Une méthode peut renvoyer une référence à un tableau et vous devez inclure les crochets avec le type de retour dans l'en-tête de la méthode.

Par exemple, la méthode suivante renvoie un tableau qui est l'inverse d'un autre tableau.

Exemple 12 :
                                    public class Test {
                                        public int[] inverser(int[] tab) {
                                            int taille = tab.length;
                                            int[] result = new int[taille];
                                    
                                            for (int i = 1; i <= taille; i++) {
                                                result[i - 1] = tab[(taille - i)];
                                            }
                                            return result;
                                        }
                                    
                                        public void affiche(int[] tab) {
                                            // afficher les éléments du tableau
                                            for (double elem : tab) {
                                                System.out.println(elem);
                                            }
                                        }
                                    
                                        public static void main(String args[]) {
                                            int[] nums = { 3, 5, 6, 8, 6, 7, 18 };
                                    
                                            Test t = new Test();
                                            int[] inv = t.inverser(nums);
                                            t.affiche(inv);
                                        }
                                    }
                            
18.0
7.0
6.0
8.0
6.0
5.0
3.0

Tableaux à deux dimensions

Java prend également en charge les tableaux à deux dimensions. les tableaux a deux dimensions ont deux colonnes de valeurs ou plus

Les deux dimensions représentent la hauteur et la largeur du tableau. Une autre façon de représenter un tableau à deux dimensions consiste à utiliser un tableau de tableaux. Il est plus facile d'imaginer des tableaux à deux dimensions ayant à la fois des lignes et des colonnes. Vous devez utiliser deux indices lorsque vous accédez à un élément dans un tableau à deux dimensions. Lorsque les mathématiciens utilisent un tableau à deux dimensions, ils l'appellent souvent une matrice ou un tableau. vous avez peut-être utilisé un tableau à deux dimensions appelé feuille de calcul.

Lorsque vous déclarez un tableau à une dimension, vous tapez une paire de crochets après le type de données du tableau. Pour déclarer un tableau à deux dimensions en Java, vous tapez deux paires de crochets après le type tableau.

Syntaxe :
                                typeDonnee[][] nomTableau=new typeDonnee[Nb_Lignes][Nb_Colonne];   // la manière préférée.
                            
Exemple 13 :
                                int[][] nums= new int[3][4];
                                Etudiant[][] etds= Etudiant[3][4];
                            

Comme avec un tableau à une dimension, si vous ne fournissez pas de valeurs pour les éléments d'un tableau numérique à deux dimensions, les valeurs par défaut sont zéro

Vous pouvez affecter d'autres valeurs aux éléments du tableau ultérieurement. Par exemple, nums[0][0] = 14; affecte la valeur 14 à l'élément du tableau nums qui se trouve dans la première colonne de la première ligne.

Vous pouvez également initialiser un tableau à deux dimensions avec des valeurs lors de sa création. Par exemple, le code suivant affecte des valeurs à nums lors de sa création:

Exemple 14 :
                                int[][] nums= { {0,1,2,3}, {4,5,6,7}, {8,9,10,11} };
                            

Passer un tableau à deux dimensions à une méthode

Lorsque vous transmettez un tableau à deux dimensions à une méthode, vous transmettez le nom du tableau comme vous le feriez avec un tableau à une dimension. Une méthode qui reçoit un tableau à deux dimensions utilise deux paires de crochets suivant le type de données dans la liste de paramètres de l’en-tête de la méthode.

Exemple 15 :
                                    public class Test {
                                        public void affiche(int[][] tab) {
                                            // afficher les éléments du tableau
                                            for (int i = 0; i < tab.length; i++) {
                                                for (int j = 0; j < tab[i].length; j++) {
                                                    System.out.println("tab[" + i + "][" + j + "]=" + tab[i][j]);
                                                }
                                            }
                                        }
                                    
                                        public static void main(String args[]) {
                                            int[][] nums = { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } };
                                    
                                            Test t = new Test();
                                            t.affiche(nums);
                                        }
                                    }
                            
tab[0][0]=0
tab[0][1]=1
tab[0][2]=2
tab[0][3]=3
tab[1][0]=4
tab[1][1]=5
tab[1][2]=6
tab[1][3]=7
tab[2][0]=8
tab[2][1]=9
tab[2][2]=10
tab[2][3]=11

Tableau irrégulier

Dans un tableau à deux dimensions, chaque ligne est également un tableau. En Java, vous pouvez déclarer chaque ligne comme ayant une longueur différente. Lorsqu'un tableau à deux dimensions comporte des lignes de longueurs différentes, il s'agit d'un tableau irrégulier, car vous pouvez imaginer que les extrémités de chaque ligne sont inégales.

Vous créez un tableau irrégulier en définissant le nombre de lignes pour un tableau à deux dimensions, mais pas le nombre de colonnes dans les lignes.

Exemple 16 :
                                int[][] nums = new int[3][];
                            

Cette instruction déclare un tableau avec trois lignes, mais les lignes ne sont pas encore créées. Ensuite, vous pouvez déclarer les lignes individuelles en fonction du nombre d'éléments que vous souhaitez placer dans chaque ligne, comme suit:

Exemple 17 :
                                nums[0] = new int[3];
                                nums[1] = new int[5];
                                nums[2] = new int[7];
                            

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :