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); 
   }
}

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);
   }
}

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); 
   }
}

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); 
   }
}

Comparatif des collections

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