DEV Community

Cover image for L'essentiel des collections en Java (List, Set, Map, Queue)
Bassaoud
Bassaoud

Posted on • Updated on

L'essentiel des collections en Java (List, Set, Map, Queue)

Java Collections Framework (JCF) est un ensemble de classes et d'interfaces en Java qui permettent de stocker, manipuler et organiser des groupes d'objets. C'est l'un des frameworks les plus populaires en Java, utilisé dans de nombreuses applications et bibliothèques. Le JCF fournit des interfaces communes pour les collections, ce qui permet aux développeurs de travailler avec différents types de collections de manière uniforme.

Les interfaces des collections

Les interfaces de collection définissent les méthodes que toutes les classes de collection doivent implémenter. Il existe plusieurs interfaces de collection dans le JCF, chacune avec ses propres méthodes et caractéristiques.

Les interfaces de collection les plus couramment utilisées sont:

  • List : représente une collection ordonnée de données. Les éléments peuvent être dupliqués et sont stockés dans l'ordre d'insertion.

  • Set : représente une collection non ordonnée de données. Les éléments ne peuvent pas être dupliqués.

  • Map : représente une collection de paires clé/valeur. Les clés sont uniques et les valeurs peuvent être dupliquées.

  • Queue : représente une file d'attente de données. Les éléments sont ajoutés à la fin de la file et retirés du début.

Les collections de type List : les listes

Les listes sont des collections ordonnées qui peuvent contenir des éléments en double. Les éléments sont stockés dans l'ordre d'insertion. Les listes sont implémentées par les classes ArrayList, LinkedList et Vector.

Les méthodes couramment utilisées avec les listes sont :

  • add(element) : ajoute un élément à la fin de la liste.
  • remove(element) : supprime la première occurrence d'un élément de la liste.
  • get(index) : renvoie l'élément à l'index spécifié dans la liste.

Exemple d'utilisation de la classe ArrayList:

import java.util.ArrayList;
import java.util.List;

public class ArrayListExample {
   public static void main(String[] args) {
      List<String> fruits = new ArrayList<>();
      fruits.add("Pomme");
      fruits.add("Banane");
      fruits.add("Orange");

      // Affiche: [Pomme, Banane, Orange]
      System.out.println(fruits); 

      fruits.remove("Banane");

      System.out.println(fruits); // Affiche: [Pomme, Orange]

      String fruit = fruits.get(1);

      // Affiche: Orange
      System.out.println(fruit); 
   }
}
Enter fullscreen mode Exit fullscreen mode

Les collections de type Set : les ensembles

Les ensembles sont des collections non ordonnées qui ne peuvent pas contenir des éléments en double. Les ensembles sont implémentés par les classes HashSet et TreeSet.

Les méthodes couramment utilisées avec les ensembles sont :

  • add(element) : ajoute un élément à l'ensemble.
  • remove(element) : supprime un élément de l'ensemble.
  • contains(element) : renvoie true si l'ensemble contient l'élément spécifié.

Exemple d'utilisation de la classe HashSet:

import java.util.HashSet;
import java.util.Set;

public class HashSetExample {
   public static void main(String[] args) {
      Set<String> fruits = new HashSet<>();
      fruits.add("Pomme");
      fruits.add("Banane");
      fruits.add("Orange");
      // L'élément en double est ignoré
      fruits.add("Pomme"); 

      // Affiche: [Banane, Orange, Pomme]
      System.out.println(fruits);

      fruits.remove("Banane");

      // Affiche: [Orange, Pomme]
      System.out.println(fruits); 

      boolean containsApple = fruits.contains("Pomme");
      // Affiche: true
      System.out.println(containsApple);
   }
}
Enter fullscreen mode Exit fullscreen mode

Les collections de type Map : les associations de type clé/valeur

Les maps sont des collections de paires clé/valeur. Les clés sont uniques et les valeurs peuvent être dupliquées. Les maps sont implémentées par les classes HashMap et TreeMap.

Les méthodes couramment utilisées avec les maps sont :

  • put(key, value) : ajoute une paire clé/valeur à la map.
  • remove(key) : supprime la paire avec la clé spécifiée.
  • get(key) : renvoie la valeur associée à la clé spécifiée.

Exemple d'utilisation de la classe HashMap:

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
   public static void main(String[] args) {
      Map<String, Integer> fruits = new HashMap<>();
      fruits.put("Pomme", 1);
      fruits.put("Banane", 2);
      fruits.put("Orange", 3);

      // Affiche: {Pomme=1, Banane=2, Orange=3}
      System.out.println(fruits); 

      fruits.remove("Banane");

      // Affiche: {Pomme=1, Orange=3}
      System.out.println(fruits); 

      int numberOfApples = fruits.get("Pomme");

      // Affiche: 1
      System.out.println(numberOfApples); 
   }
}
Enter fullscreen mode Exit fullscreen mode

Les collections de type Queue : les files

Les files sont des collections où les éléments sont ajoutés à la fin et retirés du début. Les files sont implémentées par les classes LinkedList et PriorityQueue.

Les méthodes couramment utilisées avec les files sont :

  • offer(element) : ajoute un élément à la fin de la file.
  • poll() : renvoie et supprime l'élément au début de la file.
  • peek() : renvoie l'élément au début de la file sans le supprimer.

Exemple d'utilisation de la classe LinkedList:

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListExample {
   public static void main(String[] args) {
      Queue<String> names = new LinkedList<>();
      names.offer("Alice");
      names.offer("Bob");
      names.offer("Charlie");

      // Affiche: [Alice, Bob, Charlie]
      System.out.println(names); 

      String firstName = names.poll();

      // Affiche: Alice
      System.out.println(firstName);

      // Affiche: [Bob, Charlie]
      System.out.println(names); 

      String nextName = names.peek();

      // Affiche: Bob
      System.out.println(nextName); 
   }
}
Enter fullscreen mode Exit fullscreen mode

Comparatif des collections

Structure de données Description Gestion d'objets dupliqués Ordre Possibilité de stocker des éléments null Accès aux éléments Exemples d'utilisation
Map Une collection paires clé-valeur (chaque clé est unique) Clés uniques, mais valeurs duplicables Non ordonnée Les clés et les valeurs peuvent être null Clé, itérateur Stockage de données d'utilisateur, traduction de mots
Set Une collection d'éléments uniques, sans ordre spécifique Element unique Non ordonnée Les éléments peuvent être null Elément ,itérateur Gestion d'abonnements, filtrage d'éléments uniques
List Une collection ordonnée d'éléments Eléments duplicables Ordonnée en fonction de l'ajout Les éléments peuvent être null Index, itérateur Stockage de données d'historique, de tâches
Queue Une collection ordonnée: accès aux éléments se fait dans l'ordre où ils ont été ajoutés Eléments duplicables Ordonné en fonction de l'ajout Les éléments peuvent être null Opérations enqueue et dequeue, itérateur Gestion de files d'attente, traitement de commandes

Conclusion

Les collections en Java sont une partie essentielle du JCF. Les collections fournissent une manière flexible et efficace de stocker et de manipuler des données. En utilisant les interfaces de collection et les implémentations de collection appropriées, les développeurs peuvent écrire des programmes plus robustes et plus flexibles. Les collections sont également utilisées pour résoudre de nombreux problèmes de programmation courants et sont essentielles à la compréhension de la programmation orientée objet en Java.

Aller plus loin: https://www.jmdoudoux.fr/java/dej/chap-collections.htm#collections-7

Top comments (0)