• 15 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 19/05/2021

Gérez les piles de données avec la bonne collection

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Imaginez que vous êtes le responsable de la communication d'un théâtre à la mode. Votre responsabilité principale consiste à gérer les premiers rangs, "Front Rows", c'est-à-dire à veiller à ce que les parents et amis invités ("Guests") par les artistes, ainsi que les autres VIP, obtiennent les meilleures places pour le spectacle.

Un enfant sur un grand siège rouge d'une salle de spectacle
Un siège d'exception pour un VIP d'exception

Si tout ce que vous aviez à faire consistait à gérer deux invitations pour l'artiste principal, vous pourriez imaginer utiliser seulement deux variables contenant le nom de l'invité. Le code Java ressemblerait à cela :

// Déclarez une variable pour chaque invité de la première rangée
String frontRowGuest1;
String frontRowGuest2;

Ensuite, lorsque l'artiste vous fournirait les informations, vous n'auriez qu'à attribuer un nom à chaque variable. Par exemple :

// Attribuez le nom des invités
frontRowGuest1="Mary Poppins";
frontRowGuest2="Jane banks"

Si le premier rang compte 30 sièges, ne serait-il pas plus facile d'utiliser une seule variable qui contiendrait toutes ces informations ?

Vous avez de la chance ! Java offre une structure de données capable de contenir un nombre fixe de valeurs d'un seul type. Cette structure s'appelle un tableau. Voyons quand et comment en utiliser un.

Utilisez un tableau pour stocker un nombre fixe d'éléments

Un tableau est une liste ordonnée numériquement d'éléments du même type. Chaque élément est associé à un numéro appelé index. L'indexation commence par 0 (pas 1 !), ce qui signifie que le premier élément est associé à un index 0, le deuxième à 1, etc.

Déclarer un tableau utilise la même syntaxe que pour n'importe quelle variable. Vous fournissez :

  1. Le type des éléments que le tableau contiendra, suivi de  [].

  2. Le nom de la variable qui doit expliciter clairement l'intention du tableau.

Par exemple, pour stocker le nombre de tasses de café que vous buvez chaque jour de la semaine, vous pouvez déclarer un tableau d'entiers avec la syntaxe suivante :

// Declarez la variable
int[] cupsOfCoffeePerDayOfTheWeek;

Créez ensuite le tableau en tant que tel d'une durée de sept jours (combien de jours y a-t-il dans une semaine ?) et initialisez le tableau avec cette durée :

// Créez le tableau et assignez-le à la variable
cupsOfCoffeePerDayOfTheWeek=new int[7];

Lorsque le tableau est créé, chaque élément est initialisé avec la valeur par défaut du type du tableau. Dans le cas d'un tableau de  int, cela signifie 0.

Vous pouvez également déclarer et créer un tableau en même temps. Voici ce que vous feriez pour déclarer une variable et l'initialiser directement avec un nouveau tableau de trois  int  :

int[] myArray = new int[3];
Déclarez une variable et créez un tableau en une seule déclaration 

Pour en revenir à notre gestion hebdomadaire du café : maintenant que le tableau est créé, vous pouvez y effectuer deux opérations :

  1. Accéder à une valeur à un index donné.

  2. Définir une nouvelle valeur à un index donné.

Dans les deux cas, vous utilisez le nom de la variable suivi de  [, la valeur de l'indice, et  ].

Par exemple, si vous buvez trois cafés le cinquième jour de la semaine, vous pouvez écrire :

// Attribuez la valeur 3 au cinquième jour de la semaine
// C'est l'index 4, puisque le premier index est 0
cupsOfCoffeePerDayOfTheWeek[4]=3;

Pour imprimer le nombre de cafés que vous buvez le premier jour de la semaine, vous pouvez écrire l'affectation suivante :

//Afficher le nombre de cafés le premier jour de la semaine
System.out.println(cupsOfCoffeePerDayOfTheWeek[0]);

Enfin, si vous souhaitez définir toutes les valeurs en même temps, vous pouvez également :

  • soit définir toutes les valeurs au moment de la création du tableau ;

  • soit utiliser une boucle qui définit chaque valeur, une par une.

Nous parlerons des boucles dans la prochaine partie du cours. Pour l'instant, créons un nouveau tableau et assignons-le à la variable cupsOfCoffeePerDayOfTheWeek :

//Créez un nouveau tableau avec toutes les valeurs et assignez-le à notre variable
cupsOfCoffeePerDayOfTheWeek=new int[]{6,2,3,7,3,4,1};

À vous de jouer !

Et le premier rang de notre salle de théâtre ? Eh bien, vous n'avez qu'à créer un tableau de chaînes avec le nombre de sièges que contient votre premier rang. Vous pouvez soit ajouter tous vos invités au moment de la création, soit les ajouter individuellement en utilisant la syntaxe  [].

Essayez les tableaux avec l'exercice interactif suivant :

Console de code
Houston... ?
Il semblerait que votre ordinateur ne soit pas connecté à Internet.
Vous n'êtes pas connecté

Connectez-vous pour accéder aux exercices de codes et testez vos nouvelles compétences.

Pensez à vous entraîner avant de terminer ce chapitre.

Si vous voulez aller plus loin et gérer tous les rangs de votre salle de spectacle, vous pouvez utiliser des tableaux multidimensionnels. Imaginons que votre théâtre contienne 30 rangs de 12 places. Voici comment créer un tableau et attribuer une valeur au sixième siège du dixième rang : 

// Créez un tableau multidimensionnel pour gérer toutes les rangs d'un théâtre
String[][] myTheatreSeats=new String[30][12];
// Rang 10, siège 6. N'oubliez pas que l'index commence à 0!
myTheatreSeats[9][5]="James Logan";

Les tableaux sont efficaces et parfaits pour gérer un nombre fixe d'éléments. Dans la pratique, vous devez souvent gérer un nombre variable d'éléments. Java facilite le traitement de ces cas avec les collections.

Commençons par la collection la plus populaire d'entre toutes, la liste.

Utilisez des listes si le nombre d'éléments n'est pas fixe

Les tableaux sont bien pratiques, mais ils ont leurs limites :

  • ils ont une taille fixe ;

  • vous ne pouvez modifier que les valeurs existantes.

Imaginons que vous vouliez classer des animaux du plus mignon au moins mignon, et que vous commenciez par un petit tableau composé de quatre éléments : renard, hibou, koala et loutre. Disons que vous voulez ajouter un écureuil et le mettre entre le renard et le hibou.

Un petit écureuil passe sa tête derrière un arbre.
Celui-ci mérite une place en haut de la liste !

Avec un tableau, vous ne pouvez pas insérer un élément supplémentaire, vous pouvez seulement remplacer des éléments. Vous ne pouvez pas non plus ajouter votre écureuil à la fin de la liste (en programmation, on appelle cela : append). Pour cela, il faudrait créer un tout nouveau tableau de cinq cases au lieu de quatre. Puis, vous devrez à nouveau ajouter tous vos éléments à la main. Ça a l'air plutôt long et ennuyeux, non ?

C'est là qu'une liste ordonnée entre en jeu ! Comme ils sont modifiables, vous pouvez modifier le contenu et le nombre d'éléments d'une collection en particulier. Après les tableaux, cela peut sembler magique ! ✨

Entre autres choses, avec les listes, vous pouvez :

  • accéder à chaque élément via son index ;

  • ajouter (append) un nouvel élément à la fin ;

  • insérer un nouvel élément à un index spécifique ;

  • supprimer un nouvel élément à un index spécifique.

Répétons-le, il s'agit de changer la valeur, pas le type. Le type ne peut pas être changé, même avec la puissance impressionnante d'une  ArrayList !

Très utile ! En Java, il existe plusieurs classes qui utilisent des listes. Vous pourriez même créer la vôtre ! L'important est que la classe que vous sélectionnez utilise l'interface  List

Une interface est un contrat qui définit toutes les opérations qu'une classe doit fournir. Dans le cas de l'interface  List, vous pouvez vérifier toutes les opérations prises en charge et la manière d'utiliser les classes sur le site web officiel des tutoriels Java (ressource en anglais).

Dans la suite de ce chapitre, nous utiliserons la classe ArrayList, qui est la plus courante. Voyons comment cela fonctionne en pratique !

Créez une liste et ajoutez des éléments

Pour créer une liste, vous devez :

  1. Déclarer une variable dont le type est l'interface  List. Cela signifie que vous pouvez assigner n'importe quel objet à la variable qui met en place l'interface List, y compris la classe  ArrayList.

  2. Initialiser la variable avec une expression commençant par le mot clé  new  qui crée une instance de la classe  ArrayList.

Ceci peut être fait en une seule ligne avec la syntaxe suivante :

List myList = new ArrayList();
Déclaration et initialisation d’une liste
  1. La déclaration a lieu avant l'opérateur d'affectation =. Tout d'abord, vous avez le type, qui est List. Ceci est directement suivi de  <Integer>, qui est le paramètre de type pour la liste. Un paramètre de type limite le type d'objets qui peuvent être stockés dans la liste. Dans cet exemple, vous ne pourrez enregistrer que des nombres entiers.

  2. La création en tant que telle a lieu avec l'expression  new ArrayList<Integer>(). L'objet initialisé est assigné à la variable  myList.

Vous avez peut-être remarqué que le mot  Integer  est écrit en toutes lettres et avec une majuscule. La raison à cela : une liste ne peut stocker que des objets, pas des types primitifs. De la même manière, vous devrez utiliser :

  • Double  au lieu de  double  si vous voulez stocker les décimales ;

  • Boolean  au lieu de  boolean  si vous voulez enregistrer des valeurs vraies/fausses ;

  • Float  au lieu de  float  si vous insistez vraiment pour les utiliser.

Mais qu'en est-il des choses que nous voulons mettre dans notre liste ?

Très bonne question ! Vous ne pouvez créer qu'une liste vide en Java. Pour y mettre des éléments, vous devez les ajouter un par un, comme ceci :

List<Integer> myList = new ArrayList<Integer>();
myList.add(7);
myList.add(5); //-> [7,5]
  1. La première affectation crée une liste vide appelée  myList.

  2. Vous ajoutez ensuite un premier élément avec l'affectation  mylist.add(7). Java place automatiquement la valeur dans un objet Integer et l'ajoute à la liste à l'index 0.

  3. Enfin, l'affectation  myList.add(5)  crée une instance de la classe  Integer avec une valeur de 5 et l'ajoute à la liste à l'index 1.

Maintenant, qu'est-ce qui se passe avec ce  .add() ? En Java, ajouter, modifier ou supprimer des éléments nécessite l'utilisation d'une méthode, et vous l'avez deviné,  .add()  en est une ! À ce stade, tout ce que vous avez besoin de savoir sur les méthodes, c'est qu'elles vous permettent de faire des choses. 😎

Pour l'interface  List, il y a trois méthodes mises en place par la classe  ArrayList  qui sont très pratiques :

  • add  – pour ajouter un nouvel élément à la fin d'un tableau. Ici, vous devez fournir un nouvel élément. Vous pouvez également insérer un nouvel élément à une position donnée en spécifiant l'index avant la valeur. Par exemple,  myList.add(1,12)  insère un entier avec la valeur 12 sur la position 1 et déplace la valeur existante sur la position 2, et ainsi de suite ;

  • set  – pour remplacer un nouvel élément sur un index spécifique. Ici, vous devez fournir un nouvel élément et l'index sur lequel vous voulez qu'une nouvelle valeur soit positionnée ;

  • remove  – pour supprimer un élément existant sur un index spécifique. Ici, vous devez fournir l'index de l'élément que vous souhaitez supprimer. Si vous n'avez plus besoin du premier élément, vous pouvez le retirer de la position 0. Cela déplacera le deuxième élément original de la position 1 à la position 0, le troisième de la position 2 à la position 1, et ainsi de suite.

Maintenant, à quoi est-ce que cela ressemble ? Voici la syntaxe Java pour ce qui précède :

List<Integer> myList = new ArrayList<Integer>(); // -> []
myList.add(7); // -> [7]
myList.add(5); //-> [7, 5]
myList.add(1,12) //-> [7, 12, 5]
myList.set(0,4); // -> [4, 12, 5]
myList.remove(1); // removed 12 -> [4, 5]

Décomposons cela un petit peu, d'accord ?

  • Vous pouvez voir la même opération que précédemment : ajouter 7, puis 5 à la liste.

  • Puis vous insérez 12 à l'index 1. La valeur existante de l'index 1 est déplacée vers l'index 2.

  • Ensuite, avec  .set(), le premier nombre fait référence à l'index, et le second donne la valeur que vous voulez y mettre. En d'autres termes, vous demandez à votre  List de modifier la valeur de l'index 0. Ceci transformera la valeur d'origine, 7, en nouvelle valeur, 4.

  • Pour finir, avec  .remove(), vous demandez à votre liste de supprimer toute valeur trouvée à l'index 1. Cela veut dire que vous lui demandez de supprimer 12.

Ceci vous laisse avec votre liste finale contenant deux entiers : 4 et 5. Imaginez faire cela avec des tableaux de taille fixe !

Assurez le suivi du nombre d'éléments dans votre liste

Il y a une méthode très importante à utiliser avec une liste,  size(), qui vous permet d'obtenir le nombre d'éléments dans une liste :

List<Integer> myList = new ArrayList<Integer>();
myList.add(1); // ->[1]
myList.add(2); //-> [1,2]
System.out.println(myList.size()); // -> 2

Ceci facilite grandement le suivi de l'emplacement des éléments de votre liste.

La méthode  size()  est largement utilisée, notamment lorsque vous avez besoin de faire une boucle sur une liste (nous avons abordé les boucles dans le chapitre 6 de la partie 1).

À vous de jouer !

Console de code
Houston... ?
Il semblerait que votre ordinateur ne soit pas connecté à Internet.
Vous n'êtes pas connecté

Connectez-vous pour accéder aux exercices de codes et testez vos nouvelles compétences.

Pensez à vous entraîner avant de terminer ce chapitre.

Collection non ordonnée – ensembles

Un ensemble (ou « set ») est une collection d'éléments uniques non ordonnés. Vous pourriez les utiliser si vous ne vous souciez pas de la commande – comme une liste d'ingrédients pour une recette. 🥑🌶🥕🌽🍅🍳

Déclarez des ensembles

Comme pour les listes, Java a différentes classes pour gérer les ensembles. Nous allons nous concentrer sur l'ensemble le plus communément utilisé, le  HashSet.

Regardons le code Java :

Set ingredients = new HashSet();
Déclarez un ensemble

Comme vous pouvez le voir, c'est assez comparable avec le fonctionnement d'une  ArrayList. Vous déclarez d'abord la variable avec l'interface  Set, et vous l'initialisez avec une instance de la classe concrète  HashSet.

Manipulez les éléments d'un ensemble

Voici les opérations fréquentes que vous pouvez utiliser avec les ensembles :

  • ajouter un nouvel élément avec une nouvelle clé ;

  • supprimer un élément pour une clé spécifique ;

  • compter le nombre d'éléments de l'ensemble.

Et l'accès à un élément ?

Comme les ensembles sont des collections non ordonnées, il n'y a pas de moyen simple de pointer des éléments particuliers – du moins pas comme ceux que vous avez vus jusqu'ici. Il y a des façons de le faire, mais vous en apprendrez davantage à ce sujet au fur et à mesure que vous approfondirez vos connaissances en programmation.

Pour ajouter un nouvel élément, utilisez  add()  :

Set<String> ingredients = new HashSet<String>();
ingredients.add("eggs");
ingredients.add("sugar");
ingredients.add("butter");
ingredients.add("salt");

Comme les ensembles sont non ordonnés, il n'est pas nécessaire d'utiliser « append » ou d'insérer des éléments à un point spécifique. Il vous suffit d'utiliser  add() !

Pour supprimer un élément, vous utilisez  remove()  :

Set<String> ingredients = new HashSet<>();
ingredients.add("salt"); //ajoutez du sel sur les ingrédients
ingredients.remove("salt"); //enlevez du sel des ingrédients

L'important, c'est de fournir l'élément exact à supprimer. Ici, vous vous débarrassez du « sel ».

Les ensembles, comme les listes, utilisent également la méthode  size()  pour obtenir le nombre d'éléments dans un ensemble :

System.out.println(ingredients.size());

À vous de jouer !

Console de code
Houston... ?
Il semblerait que votre ordinateur ne soit pas connecté à Internet.
Vous n'êtes pas connecté

Connectez-vous pour accéder aux exercices de codes et testez vos nouvelles compétences.

Pensez à vous entraîner avant de terminer ce chapitre.

Les dictionnaires ou "maps"

Un dictionnaire est une liste d'éléments organisés en fonction d'une clé. Cette clé est un terme spécifique que vous recherchez pour trouver sa définition ou sa valeur. C'est ce qu'on appelle une association "Clé <> Valeur".

Par exemple, si vous voulez lister les noms de vos amis et leurs âges respectifs, les dictionnaires sont la bonne collection à utiliser :

Collection d'éléments organisés par clé : Jenny = 34 Livia = 28 Paul = 31
Éléments du dictionnaire

Toutes les clés d'un dictionnaire doivent être uniques, tout comme une seule personne ne peut s'asseoir que sur une chaise à la fois.

Déclarez des dictionnaires

Comme pour les listes et les ensembles, Java fournit plusieurs classes pour manipuler les dictionnaires. Chacune de ces classes respecte l'interface  Map, pour laquelle vous pouvez consulter la documentation complète sur le site des tutoriels Java (en anglais).

Pour cette section, nous utiliserons la classe la plus courante,  HashMap. Voici le code pour déclarer et initialiser une instance de cette classe :

Déclarez un dictionnaire
Déclarez un dictionnaire

La différence principale, en comparaison avec les listes et les ensembles, réside dans le fait que vous paramétrez votre dictionnaire avec deux éléments, en utilisant la syntaxe <String, Integer>.

  1. String  est le type de la clé.

  2. Integer  est le type de la valeur.

Pour ajouter des éléments à votre dictionnaire, utilisez la méthode  myMap.put(). Entre parenthèses, indiquez d'abord la clé, puis la valeur :

// Les âges de mes amis
myMap.put("Jenny", 34);
myMap.put("Livia", 28);
myMap.put("Paul", 31);
System.out.println(myMap.get("Jenny")); // -> 34

Dans la dernière ligne, nous avons demandé au programme d'imprimer la valeur de la clé, Jenny. Dans ce code :

  • la méthode  System.out.println()  imprime le résultat d'une expression fournie entre parenthèses ;

  • l'expression réelle,  myMap.get("Jenny"), renvoie la valeur identifiée par la touche "Jenny", qui est stockée dans la variable myMap.

Lorsque vous utilisez des chaînes comme clés, n'oubliez pas que ces clés sont sensibles à la casse. Ainsi, "Jenny" et "jenny" sont (par exemple) deux clés différentes associées à deux éléments différents dans un dictionnaire. Par exemple :

myMap.put("Jenny", 34);
myMap.put("Livia", 28);
myMap.put("Paul", 31);
myMap.put("jenny", 21);
System.out.println(myMap.get("Jenny")); // -> 34
System.out.println(myMap.get("jenny")); // -> 21

Pour éviter de telles situations, une astuce consiste à utiliser des constantes pour spécifier les clés une fois et les réutiliser ensuite dans tout le code :

// Définissez des clés en tant que constantes
private static final String kJenny = "Jenny";
private static final String kLivia = "Livia";
private static final String kPaul = "Paul";
// Utilisez des constantes en tant que keys
myMap.put(kJenny, 34);
myMap.put(kLivia, 28);
myMap.put(kPaul, 31);
// Accédez à un élément
System.out.println(myMap.get(kJenny)); // -> 34

Vous voyez que vous devez utiliser ici les mots clés  private static final  pour indiquer que vous avez besoin que vos chaînes soient des constantes et non des variables. Ceci est très utile, car cela vous garantit que vous garderez vos clés pour toujours et que vous ne perdrez aucune donnée en changeant accidentellement les chaînes de clés !

Parlons encore un peu des clés

Si le type le plus couramment utilisé est  String, les clés en Java peuvent être de différents types, par exemple  Integer  :

morning.put(1, "Wake up");

Tout comme pour les types de variables et les tableaux simples, les mêmes règles s'appliquent aux dictionnaires : ils ont toujours un type qui ne peut pas être modifié. Toutes les valeurs dans un dictionnaire doivent être du même type. Et toutes les clés doivent être du même type :

myMap.put(kJenny, 34);
myMap.put(kLivia, 28); // Ok
myMap.put("Paul", "Designer") // Error

Manipulez les éléments du dictionnaire

Voici les opérations fréquemment utilisées que vous pouvez effectuer avec les dictionnaires :

  • accéder à la valeur d'un élément par sa clé ;

  • ajouter un nouvel élément avec une nouvelle clé et une valeur ;

  • supprimer un élément pour une clé spécifique.

Imaginons un dictionnaire de noms de personnes et de leur profession, appelé « professions ».

  1. Vous pouvez ajouter une valeur avec une méthode  put()  et deux arguments : la clé et la valeur.

  2. Pour accéder à une valeur, utilisez simplement la méthode  get()  avec la clé en argument.

Allons jeter un coup d'œil à cela :

professions.put("Jenny", "Business owner");
System.out.println(professions.get("Jenny")); // -> Business owner

Vous pouvez également modifier un élément en réutilisant une clé existante avec la méthode  put()  :

professions.put("Jenny", "Business owner");
System.out.println(professions.get("Jenny")); // -> Business owner
professions.put("Jenny", "Developer");
System.out.println(professions.get("Jenny")); // -> Developer

Enfin, pour supprimer un élément, vous pouvez utiliser une méthode  remove()  avec la clé de l'élément que vous voulez supprimer :

professions.remove("Jenny");

Comptez les éléments

Les dictionnaires, comme les listes et les ensembles, ont aussi la propriété  size()  qui permet d'obtenir le nombre d'éléments du dictionnaire : 

System.out.println(professions.size());

À vous de jouer !

Console de code
Houston... ?
Il semblerait que votre ordinateur ne soit pas connecté à Internet.
Vous n'êtes pas connecté

Connectez-vous pour accéder aux exercices de codes et testez vos nouvelles compétences.

Pensez à vous entraîner avant de terminer ce chapitre.

En résumé

Dans ce chapitre, vous avez appris les bases pour travailler avec des conteneurs qui stockent plusieurs éléments d'un type de données en particulier :

  • conteneurs de taille fixe : Arrays – les éléments d'un tableau sont indexés à partir de 0 et sont accessibles à l'aide de cet index. Le nombre d'éléments ne peut pas être modifié ;

  • listes ordonnées : Lists – les éléments d'une liste se comportent comme un tableau. Le nombre d'éléments peut évoluer en ajoutant et en supprimant des éléments ;

  • listes non ordonnées : Sets – les éléments d'un ensemble sont stockés sans ordre particulier. Vous pouvez y accéder en les énumérant ;

  • dictionnaires : Maps – les éléments d'un dictionnaire sont organisés par paires clé-valeur et sont accessibles à l'aide d'une clé ;

  • les actions les plus courantes effectuées avec les collections sont :

    • accéder à un élément,

    • ajouter un nouvel élément,

    • supprimer un élément,

    • modifier un élément,

    • compter tous les éléments,

    • parcourir tous les éléments.

La collection que vous choisissez dépend de la tâche à accomplir. Au fur et à mesure que vous progressez dans votre carrière, vous serez en mesure d'identifier le type le plus approprié à utiliser.

Terminons avec le passage de paramètre et les valeurs de retour. À tout de suite !

Exemple de certificat de réussite
Exemple de certificat de réussite