L'essentiel des collections en Java (List, Set, Map, Queue)
Tags: java, list, map, set
Published: 2023-03-18 23:07:44

**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:
```Java
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**:
```Java
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:
```Java
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**:
```Java
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

| 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](https://www.jmdoudoux.fr/java/dej/chap-collections.htm#collections-7)