Tableaux en Java

Imaginez des armoires dans une salle de stockage. Chacun d'eux a son propre numéro, et chacun d'eux stocke un objet Bagage. Ou une carte des vins où chaque type de vin est numéroté et vous commandez en donnant le numéro de votre boisson. Ou une liste d'étudiants dans laquelle "Adams" est enregistré en première position et "Zimmer" en dernier. Ou une liste de passagers dans un avion, chacun d'entre eux se voyant attribuer un siège numéroté. En Java, les tableaux sont souvent utilisés pour travailler avec de telles structures, c'est-à-dire des ensembles de données homogènes.

Qu'est-ce qu'un tableau ?

Un tableau est une structure de données qui stocke des éléments du même type. Vous pouvez le considérer comme un ensemble de cellules numérotées. Vous pouvez mettre des données dans chaque cellule (un élément de données par cellule). Une cellule spécifique est accessible à l'aide de son numéro. Le numéro d'un élément dans le tableau est également appelé index . En Java, un tableau est homogène, c'est-à-dire que toutes ses cellules contiennent des éléments de même type. Ainsi, un tableau d'entiers ne contient que des entiers ( int ), un tableau de chaînes — uniquement des chaînes, et un tableau d'instances d'une classe Dog que nous avons créée ne contiendra que des objets Dog . En d'autres termes, Java ne nous laissera pas mettre un entier dans la première cellule du tableau, une chaîne dans la seconde et un chien dans la troisième.

Déclarer un tableau

Comment déclarer un tableau ?

Comme toute variable, un tableau doit être déclaré en Java. Cela peut être fait de deux manières. Ils sont équivalents, mais la première méthode est plus cohérente avec le style Java. La seconde est un héritage du langage C : de nombreux programmeurs C sont passés à Java, et une méthode alternative a été conservée pour leur commodité. Le tableau montre les deux manières de déclarer un tableau en Java:Dans les deux cas, dataType est le type des variables du tableau. Dans les exemples, nous avons déclaré deux tableaux. L'un stockera des int s et l'autre des objets Object . Ainsi, une déclaration de tableau a un nom et un type (le type des éléments du tableau). ArrayName est le nom du tableau.

Création d'un tableau

Comment crée-t-on un tableau ?

Comme tout autre objet, vous pouvez créer un tableau Java, c'est-à-dire lui réserver une place en mémoire, à l'aide de l' opérateur new . Voici comment c'est fait :

new typeOfArray[length]; 

où typeOfArray est le type du tableau et length est sa longueur (c'est-à-dire le nombre de cellules) exprimée sous la forme d'un nombre entier ( int). Mais notez qu'ici, nous n'avons alloué de la mémoire qu'au tableau - nous n'avons associé le tableau déclaré à aucune variable précédemment déclarée. Généralement, un tableau est d'abord déclaré puis instancié, par exemple :

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

Ici, nous avons créé un tableau d'entiers appelé myArray , informant le compilateur qu'il se compose de 10 cellules (chacune contenant un entier). Cependant, il est beaucoup plus courant d'utiliser la syntaxe abrégée suivante pour créer un tableau immédiatement après sa déclaration :

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

Veuillez noter:Une fois qu'un tableau est créé à l'aide de l' opérateur new , ses cellules contiennent des valeurs par défaut. Pour les types numériques (comme dans notre exemple), la valeur par défaut est 0, pour le type booléen , c'est false , et pour les types référence, c'est null . Ainsi, après avoir exécuté cette instruction

int[] myArray = new int[10];

nous obtenons un tableau de dix entiers et, jusqu'à ce que le programme fasse quelque chose pour changer les valeurs, chaque cellule contient 0.

Longueur de tableau en Java

Comme nous l'avons dit plus haut, la longueur d'un tableau est le nombre d'éléments que le tableau est conçu pour contenir. La longueur d'un tableau ne peut pas être modifiée après sa création. Veuillez noterque les éléments du tableau sont numérotés à partir de zéro en Java. Ainsi, si nous avons un tableau de 10 éléments, alors l'indice du premier élément est 0 et l'indice du dernier est 9. Vous pouvez obtenir la longueur du tableau en utilisant la variable de longueur . Par exemple:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

Sortir:

10

Initialiser un tableau et accéder à ses éléments

Nous savons maintenant comment créer un tableau en Java. Le processus ne nous donne pas un tableau vide, mais un tableau rempli de valeurs par défaut. Par exemple, pour un tableau int , c'est 0, et si nous avons un tableau de n'importe quel type de référence, alors la valeur par défaut dans chaque cellule est null . Nous accédons à un élément de tableau (par exemple, pour définir sa valeur, l'afficher à l'écran ou effectuer une opération avec lui) par son index. L'initialisation d'un tableau est le processus de remplissage d'un tableau avec des valeurs spécifiques (autres que la valeur par défaut). Exemple : créons un tableau de chaînes pour les 4 saisons et remplissons-le avec les noms des saisons.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

Maintenant, les noms des saisons sont écrits dans les quatre cellules de notre tableau. Nous pourrions initialiser le tableau d'une manière différente, en combinant la déclaration et l'initialisation :

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

De plus, le nouvel opérateur peut être omis :

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

Comment afficher un tableau à l'écran en Java ?

Vous pouvez afficher les éléments du tableau à l'écran (c'est-à-dire sur la console) à l'aide d'une boucle for . Une autre manière, plus courte, d'afficher un tableau sera abordée dans le paragraphe intitulé " Méthodes utiles pour travailler avec des tableaux ". En attendant, regardez cet exemple où un tableau est affiché à l'aide d'une boucle :

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

Le programme affichera ce qui suit :

Winter 
Spring 
Summer 
Autumn

Tableaux unidimensionnels et multidimensionnels en Java

Mais que se passe-t-il si nous voulons créer non pas un tableau de nombres, de chaînes ou d'autres objets, mais plutôt un tableau de tableaux ? Java vous permet de le faire. Le type de tableau que nous connaissons déjà ( int[] myArray = new int[8] ) est connu sous le nom de tableau unidimensionnel. Mais un tableau de tableaux est appelé un tableau à deux dimensions. C'est comme un tableau qui a un numéro de ligne et un numéro de colonne. Ou, si vous avez appris les bases de l'algèbre linéaire, vous pouvez la considérer comme une matrice. Pourquoi avons-nous besoin de tels tableaux ? Eh bien, pour programmer des matrices et des tables, ainsi que d'autres objets ayant une structure similaire. Par exemple, un échiquier peut être représenté par un tableau 8x8. Un tableau multidimensionnel est déclaré et créé comme suit :

Int[][] myTwoDimentionalArray = new int[8][8];

Ce tableau contient exactement 64 éléments : myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] et ainsi de suite jusqu'à myTwoDimentionalArray[7][7] . Donc si on l'utilise pour représenter un échiquier, alors A1 correspond à myTwoDimentionalArray[0][0] et E2 correspond à myTwoDimentionalArray[4][1] . Mais jusqu'où peut-on pousser cela ? En Java, vous pouvez spécifier un tableau de tableaux... un tableau de tableaux de tableaux, etc. Bien sûr, les tableaux tridimensionnels et de dimension supérieure sont très rarement utilisés. Cela dit, vous pouvez utiliser un tableau tridimensionnel pour programmer un Rubik's cube, par exemple.

Méthodes utiles pour travailler avec des tableaux

Java a la classe java.util.Arrays pour travailler avec des tableaux. En général, les opérations les plus courantes effectuées sur les tableaux sont l'initialisation (remplissage d'éléments), la récupération d'un élément (par index), le tri et la recherche. La recherche et le tri des tableaux sont des sujets pour un autre jour. D'une part, il est recommandé d'écrire soi-même plusieurs algorithmes de recherche et de tri. D'autre part, tous les meilleurs algorithmes ont déjà été implémentés et inclus dans les bibliothèques Java standard, et vous pouvez les utiliser légalement. Voici trois méthodes utiles dans cette classe.

Trier un tableau

La méthode void sort(int[] myArray, int fromIndex, int toIndex) trie un tableau ou un sous-tableau d'entiers par ordre croissant.

Recherche d'un élément dans un tableau

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key) . Cette méthode recherche l' élément clé dans un tableau ou un sous-tableau myArray trié , de fromIndex à toIndex . Si l'élément est trouvé, il renvoie son index. Sinon, il renvoie (-fromIndex)-1 .

Conversion d'un tableau en chaîne

La méthode String toString(int[] myArray) convertit un tableau en chaîne. En Java, les tableaux ne remplacent pas toString() . Cela signifie que si vous essayez d'afficher un tableau entier d'un coup (System.out.println(myArray)) plutôt qu'un élément à la fois comme dans le paragraphe intitulé " Afficher un tableau à l'écran ", vous obtiendrez le nom de la classe et le hachage hexadécimal du tableau (défini par Object.toString() ). Si vous êtes débutant, vous ne comprendrez peut-être pas l'explication de la méthode toString . Au départ, vous n'en avez pas besoin, mais l'utilisation de cette méthode facilite l'affichage d'un tableau. Java vous permet d'afficher facilement un tableau sans utiliser de boucle. L'exemple ci-dessous le démontre.

Un exemple utilisant sort, binarySearch et toString

Créons un tableau d'entiers, affichons-le à l'aide de toString , trions-le à l'aide de la méthode sort , puis trouvons-y un nombre.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

Sortir:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

La première chaîne est une tentative d'affichage du tableau sans utiliser toString . Le second est le tableau affiché à l'aide de toString . Le troisième est le tableau trié. Le quatrième est l'indice du nombre que nous avons recherché (5) dans le tableau trié (rappelez-vous que nous comptons à partir de zéro, donc l'indice du quatrième élément du tableau est 3). Dans la cinquième chaîne, nous voyons -1. Il s'agit d'un index de tableau non valide. Cela signale que le nombre que nous avons recherché (dans ce cas, 0) n'est pas dans le tableau.

Les tableaux en bref

• Caractéristiques essentielles d'un tableau : le type des données qui y sont placées, son nom et sa longueur.
  La dernière propriété est déterminée lors de la création du tableau (lorsque la mémoire est allouée au tableau). Les deux premières propriétés sont déterminées lors de la déclaration du tableau.

• La taille du tableau (nombre de cellules) doit être un entier

• Il est impossible de modifier la longueur d'un tableau après sa création.

• Un élément de tableau est accessible par son index.

• Les éléments des tableaux, comme tout le reste en Java, sont numérotés à partir de zéro.

• Une fois qu'un tableau est créé, il est rempli de valeurs par défaut.

• Les tableaux en Java ne sont pas les mêmes que les tableaux en C++. Ils sont presque comme des pointeurs vers des tableaux dynamiques.

Matériel utile sur les tableaux

Vous voulez en savoir plus sur les tableaux ? Consultez les articles ci-dessous. Il y a beaucoup de matériel intéressant et utile sur ce sujet.