Tableaux en Java

Imaginez des cellules dans une salle de stockage. Chacun a son propre numéro et chacun contient une sorte d’objet « Bagage ». Ou encore une carte des vins, dans laquelle tous les types de vins sont numérotés et lorsque vous passez commande, il vous suffit de donner le numéro de la boisson. Ou une liste d'étudiants d'un groupe, dans laquelle l'étudiant « Andreev » sera écrit dans la première cellule et « Yakovlev » dans la dernière cellule. Ou une liste de passagers d'avion, chacun se voyant attribuer un siège avec un numéro précis. En Java, pour travailler avec des structures similaires, c'est-à-dire beaucoup de données homogènes, des tableaux en Java sont souvent utilisés.

Qu'est-ce qu'un tableau ?

Un tableau est une structure de données qui stocke des éléments du même type. Il peut être considéré comme un ensemble de cellules numérotées, chacune pouvant contenir des données (un élément de données par cellule). L'accès à une cellule spécifique s'effectue via son numéro. Le numéro d'un élément dans un tableau est également appelé index . Dans le cas de Java, le tableau est homogène, c'est-à-dire que toutes ses cellules stockeront des éléments du même type. Ainsi, un tableau d'entiers ne contient que des entiers (par exemple, de type int ), un tableau de chaînes ne contient que des chaînes, un tableau d'éléments de la classe Dog que nous avons créé ne contiendra que des objets Dog . Autrement dit, en Java, nous ne pouvons pas mettre un entier dans la première cellule d'un tableau, une chaîne dans la seconde et un « chien » dans la troisième.

Déclaration de tableau

Comment déclarer un tableau ?

Comme toute variable, un tableau en Java doit être déclaré. Vous pouvez le faire de deux manières. Ils sont équivalents, mais le premier est plus cohérent avec le style Java. Le second est l'héritage du langage C (de nombreux programmeurs C sont passés à Java et, pour leur commodité, une méthode alternative a été laissée). 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 entiers de type int , l’autre stockera des objets de type Object . Ainsi, lorsqu'un tableau est déclaré, il a un nom et un type (le type des variables du tableau). arrayName est le nom du tableau.

Création d'un tableau

Comment créer un tableau ?

Comme tout autre objet, vous pouvez créer un tableau Java, c'est-à-dire lui réserver de l'espace mémoire, à l'aide de l' opérateur new . Cela se fait comme ceci :

new typeOfArray [length];

Où typeOfArray est le type du tableau et length est sa longueur (c'est-à-dire le nombre de cellules), exprimée en nombres entiers ( int ). Cependant, ici, nous avons uniquement alloué de la mémoire pour le tableau, mais n'avons associé le tableau créé à aucune variable précédemment déclarée. Habituellement, un tableau est d'abord déclaré puis créé, par exemple :

int[] myArray; // array declaration
myArray = new int[10]; // creation, that is, allocation of memory for an array of 10 elements of type int

Ici, nous avons déclaré un tableau d'entiers appelé myArray , puis déclaré qu'il se compose de 10 cellules (dont chacune stockera un entier). Cependant, il est beaucoup plus courant de créer un tableau immédiatement après la déclaration en utilisant cette syntaxe abrégée :

int[] myArray = new int[10]; // declaration and allocation of memory "in one bottle"

Note:Après avoir créé un tableau à l'aide de new , ses cellules sont remplies de valeurs par défaut. Pour les types numériques (comme dans notre exemple), ce sera 0, pour boolean - false , pour les types référence - null . Ainsi, après l'opération

int[] myArray = new int[10];

nous obtenons un tableau de dix nombres entiers, et jusqu'à ce que cela change au cours du programme, chaque cellule contient un 0.

Longueur du tableau en Java

Comme nous l'avons dit ci-dessus, la longueur d'un tableau correspond au nombre d'éléments pour lesquels le tableau est conçu. La longueur d'un tableau ne peut pas être modifiée une fois qu'il est créé. Note:En Java, les éléments du tableau sont numérotés à partir de zéro. Autrement dit, si nous avons un tableau de 10 éléments, alors le premier élément du tableau aura l'index 0 et le dernier aura l'index 9. Vous pouvez accéder à la longueur du tableau en utilisant la variable length . Exemple:

int[] myArray = new int[10]; // created an array of integers with 10 elements and named it myArray
System.out.println(myArray.length); // printed to the console the length of the array, that is, the number of elements that we can put in the array

Résultat du programme :

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

Comment créer un tableau en Java est déjà clair. Après cette procédure, nous n'obtenons pas un tableau vide, mais un tableau rempli de valeurs par défaut. Par exemple, dans le cas de int, ce sera 0, et si nous avons un tableau avec des données de type référence, alors par défaut, null est écrit dans chaque cellule . Nous accédons à un élément du tableau (c'est-à-dire que nous y écrivons une valeur, l'affichons à l'écran ou effectuons une opération avec lui) par son index. Initialiser un tableau consiste à le remplir de données spécifiques (pas par défaut). Exemple : créons un tableau de 4 saisons et remplissons-le de valeurs de chaîne - les noms de ces saisons.

String[] seasons  = new String[4]; /* declared and created an array. Java allocated memory for an array of 4 strings, and now each cell is null (because the string is a reference type)*/

seasons[0] = "Winter"; /* in the first cell, that is, in the cell with a zero number, we wrote the string Winter. Here we get access to the zero element of the array and write a specific value there */
seasons[1] = "Spring"; // do the same procedure with cell number 1 (second)
seasons[2] = "Summer"; // ...number 2
seasons[3] = "Autumn"; // and with the last one, number 3

Désormais, les quatre cellules de notre tableau contiennent les noms des saisons. L'initialisation peut également se faire différemment, en combinant initialisation et déclaration :

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 en Java à l'écran ?

Vous pouvez afficher les éléments du tableau à l'écran (c'est-à-dire sur la console), par exemple à l'aide d'une boucle for . Une autre manière plus courte d'afficher un tableau à l'écran sera abordée dans le paragraphe "Méthodes utiles pour travailler avec des tableaux" ci-dessous. Pour l'instant, regardons un exemple avec une sortie cyclique d'un tableau :

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

En conséquence, le programme affichera le résultat suivant :

Tableaux Java unidimensionnels et multidimensionnels

Que se passe-t-il si nous voulons créer non pas un tableau de nombres, un tableau de chaînes ou un tableau de certains objets, mais un tableau de tableaux ? Java vous permet de le faire. Le tableau déjà familier int[] myArray = new int[8] est ce qu'on appelle un tableau unidimensionnel. Et un tableau de tableaux est appelé bidimensionnel. C'est comme un tableau comportant un numéro de ligne et un numéro de colonne. Ou, si vous avez appris les débuts de l’algèbre linéaire, sur une matrice. Pourquoi de tels tableaux sont-ils nécessaires ? En particulier, pour programmer les mêmes matrices et tableaux, ainsi que des objets qui leur ressemblent en structure. Par exemple, le terrain de jeu des échecs peut être spécifié sous la forme d’un tableau 8x8. Un tableau multidimensionnel est déclaré et créé comme suit :

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

Il y a exactement 64 éléments dans ce tableau : myTwoDimentionalArray[0][0], myTwoDimentionalArray[0][1], myTwoDimentionalArray[1][0], myTwoDimentionalArray[1][1]et ainsi de suite jusqu'à myTwoDimentionalArray[7][7]. Donc, si nous l’utilisons pour représenter un échiquier, alors la cellule A1 représentera myTwoDimentionalArray[0][0]et E2 représentera myTwoDimentionalArray[4][1]. Là où il y en a deux, il y en a trois. En Java, vous pouvez spécifier un tableau de tableaux... un tableau de tableaux de tableaux, et ainsi de suite. Certes, les tableaux tridimensionnels et plus sont très rarement utilisés. Cependant, à l'aide d'un tableau tridimensionnel, vous pouvez programmer, par exemple, un Rubik's cube.

Méthodes utiles pour travailler avec des tableaux

Pour travailler avec des tableaux en Java, il existe une classe java.util.Arrays (arrays en anglais signifie « tableaux »). De manière générale, les opérations suivantes sont le plus souvent effectuées avec les tableaux : remplissage par des éléments (initialisation), récupération d'un élément (par numéro), tri et recherche. La recherche et le tri des tableaux sont un sujet distinct. D'une part, il est très utile de pratiquer et d'écrire soi-même plusieurs algorithmes de recherche et de tri. En revanche, toutes les bonnes pratiques ont déjà été écrites et incluses dans les bibliothèques Java, et peuvent être utilisées légalement. Voici trois méthodes utiles de cette classe

Trier un tableau

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

Rechercher dans un tableau l'élément souhaité

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key). Cette méthode recherche l' élément clé dans un myArray ou un sous-tableau déjà trié , en commençant par fromIndex et en terminant par toIndex . Si l'élément est trouvé, la méthode renvoie son index, sinon - . (-fromIndex)-1

Conversion d'un tableau en chaîne

La méthode String toString(int[] myArray)convertit le tableau en chaîne. Le fait est que dans les tableaux Java, ne remplacez pas toString() . Cela signifie que si vous essayez d'afficher le tableau entier (plutôt qu'élément par élément, comme dans « Impression d'un tableau à l'écran ») directement à l'écran ( System.out.println(myArray)), vous obtiendrez le nom de la classe et le code de hachage hexadécimal du tableau. (ceci est défini par Object.toString() ). Si vous êtes débutant, vous ne comprendrez peut-être pas l’explication de la méthode toString. Dans un premier temps, cela n'est pas nécessaire, mais en utilisant cette méthode, la sortie du tableau est simplifiée. Java facilite l'affichage d'un tableau sans utiliser de boucle. Plus d'informations à ce sujet dans l'exemple ci-dessous.

Exemple sur le tri, la recherche binaire et toString

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

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; //declaring and initializing the array
        System.out.println(array);//trying to display our array on the screen without the toString method - we get a hexadecimal number
        System.out.println(Arrays.toString(array));//печатаем массив "правильно"
        Arrays.sort(array, 0, 4); // sort the entire array from zero to the fourth member
        System.out.println(Arrays.toString(array));//print the sorted array to the screen
        int key = Arrays.binarySearch(array, 5); // ищем key - число 5 в отсортированном массиве.
        //binarySearch method will return the index of the sorted array element, in which the required number is "hidden"
        System.out.println(key);//распечатываем индекс искомого числа
System.out.println(Arrays.binarySearch(array, 0));//а теперь попробуем найти число, которого в массиве нет,
        // and immediately display the result on the screen

    }
}

Résultat du programme : La première ligne est une tentative d'affichage d'un tableau sans toString , la seconde affiche un tableau en utilisant toString , la troisième est un tableau trié, la quatrième est l'index du nombre souhaité 5 dans un tableau trié (rappelez-vous que nous comptons à partir de zéro, donc le quatrième élément du tableau a un indice 3). Dans la cinquième ligne, nous voyons la valeur -1 . Un tableau n'a pas un tel index. La sortie signale que l'élément souhaité (dans ce cas, 0) n'est pas dans le tableau.

L'essentiel à propos des tableaux

• Les principales caractéristiques d'un tableau : le type de données qui y sont placées, son nom et sa longueur.
  Ce dernier est décidé lors de l'initialisation (allocation de mémoire pour le tableau), les deux premiers paramètres sont déterminés lors de la déclaration du tableau.

• La taille du tableau (nombre de cellules) doit être définie en int

• Vous ne pouvez pas modifier la longueur d'un tableau une fois qu'il a été créé.

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

• Dans les tableaux, comme ailleurs en Java, les éléments sont numérotés à partir de zéro.

• Après la procédure de création du tableau, il est rempli avec les valeurs par défaut.

• Les tableaux en Java sont structurés différemment qu'en C++. Ils sont presque identiques aux pointeurs vers des tableaux dynamiques.

Documents utiles sur les tableaux

Vous voulez en savoir plus sur les tableaux ? Veuillez jeter un œil aux articles ci-dessous. Il existe de nombreuses informations intéressantes et utiles sur ce sujet.

1. Something About Arrays - Bon article détaillé sur les tableaux

2. La classe Arrays et son utilisation - l'article décrit quelques méthodes de la classe Array

3. Tableaux multidimensionnels - un article détaillé sur les tableaux multidimensionnels avec des exemples.

4. Renvoie un tableau de longueur nulle, pas nul - Joshua Bloch, auteur d'Effective Programming, explique comment mieux renvoyer des tableaux vides