Collections en Java : Implémentations et cas d'utilisation (List, Set et Map)
Tags: java, collections, list, set
Published: 2023-03-19 19:36:49

Java est un langage de programmation largement utilisé pour créer des applications de toutes sortes. L'une des fonctionnalités clés de Java est la prise en charge des collections, qui permettent aux développeurs de stocker, de manipuler et d'accéder facilement à des groupes d'objets. Les collections Java peuvent être utilisées pour stocker différents types de données, telles que des entiers, des chaînes de caractères, des objets, etc.

Dans cet article, nous allons examiner en détail trois types de collections Java : List, Set et Map.

### List

Une liste est une collection ordonnée qui permet des doublons. Les éléments d'une liste sont stockés dans un ordre spécifique et peuvent être accédés par leur index. Les listes sont utiles pour stocker des données qui doivent être manipulées dans un ordre précis.

Voici un exemple de création et de manipulation d'une liste en Java :
```Java
List<String> myList = new ArrayList<>();

// Ajouter des éléments à la liste
myList.add("élément 1");
myList.add("élément 2");
myList.add("élément 3");

// Accéder à un élément de la liste
String element = myList.get(0);

// Parcourir tous les éléments de la liste
for (String str : myList) {
    System.out.println(str);
}

// Supprimer un élément de la liste
myList.remove(1);

// Taille de la liste
int size = myList.size();
```
Dans cet exemple, nous avons créé une liste vide et ajouté trois éléments à la liste. Nous avons accédé au premier élément de la liste en utilisant la méthode get() et avons parcouru tous les éléments de la liste à l'aide d'une boucle for. Nous avons également supprimé un élément de la liste à l'aide de la méthode remove() et avons obtenu la taille de la liste à l'aide de la méthode size().

### Set

Un ensemble est une collection non ordonnée qui ne permet pas les doublons. Les éléments d'un ensemble ne sont pas stockés dans un ordre spécifique et ne peuvent être accédés par leur index. Les ensembles sont utiles pour stocker des données uniques qui n'ont pas besoin d'être ordonnées.

Voici un exemple de création et de manipulation d'un ensemble en Java :
```Java
Set<String> mySet = new HashSet<>();

// Ajouter des éléments à l'ensemble
mySet.add("élément 1");
mySet.add("élément 2");
mySet.add("élément 3");

// Vérifier si l'ensemble contient un élément
boolean contains = mySet.contains("élément 1");

// Parcourir tous les éléments de l'ensemble
for (String str : mySet) {
    System.out.println(str);
}

// Supprimer un élément de l'ensemble
mySet.remove("élément 2");

// Taille de l'ensemble
int size = mySet.size();
```
Dans cet exemple, nous avons créé un ensemble vide et ajouté trois éléments à l'ensemble. Nous avons vérifié si l'ensemble contenait un élément spécifique en utilisant la méthode contains() et avons parcouru tous les éléments de l'ensemble à l'aide d'une boucle for. Nous avons également supprimé un élément de l'ensemble à l'aide de la méthode remove() et avons obtenu la taille de l'ensemble à l'aide de la méthode size().

### Map

Map est une collection qui stocke des éléments sous forme de paires clé-valeur. Ses élements ne sont pas stockés dans un ordre spécifique et peuvent être accédés par leur clé. Map est utile pour stocker des données qui doivent être récupérées rapidement en utilisant une clé.

Voici un exemple de création et de manipulation d'une collection Map en Java :
```Java
Map<Integer, String> myMap = new HashMap<>();

// Ajouter des éléments à la Map
myMap.put(1, "élément 1");
myMap.put(2, "élément 2");
myMap.put(3, "élément 3");

// Accéder à un élément de la Map en utilisant sa clé
String element = myMap.get(1);

// Vérifier si la Map contient une clé spécifique
boolean containsKey = myMap.containsKey(2);

// Vérifier si la Map contient une valeur spécifique
boolean containsValue = myMap.containsValue("élément 3");

// Parcourir toutes les paires clé-valeur de la Map
for (Map.Entry<Integer, String> entry : myMap.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

// Supprimer une paire clé-valeur de la Map
myMap.remove(2);

// Taille de la Map
int size = myMap.size();
```
Dans cet exemple, nous avons créé une Map vide et ajouté trois paires clé-valeur à l'intérieur. Nous avons accédé à la valeur associée à une clé spécifique en utilisant la méthode get() et avons vérifié si la Map contenait une clé ou une valeur spécifique à l'aide des méthodes containsKey() et containsValue(). Nous avons également parcouru toutes les paires clé-valeur de la Map à l'aide d'une boucle for et avons supprimé une paire clé-valeur de la Map à l'aide de la méthode remove(). Enfin, nous avons obtenu la taille de la Map à l'aide de la méthode size().


#### Implémentations utiles
- Les implémentations les plus populaires de List en Java sont ArrayList, LinkedList et Vector. ArrayList est plus général et permet un accès aléatoire par index, tandis que LinkedList est plus adapté pour ajouter et supprimer fréquemment des éléments dans List. Vector est une version synchronisée d'ArrayList. 

- Les implémentations les plus populaires de Set sont HashSet, LinkedHashSet et TreeSet. La première est un Set général qui est basé sur HashMap. Elle permet des opérations de base (ajout, suppression, recherche) en temps constant, mais ne garantit pas l'ordre des éléments. LinkedHashSet est similaire à HashSet, mais maintient l'ordre d'insertion des éléments. TreeSet, quant à lui, maintient les éléments triés selon un ordre naturel ou un comparateur fourni.

- Pour Map, les implémentations les plus courantes en Java sont HashMap, LinkedHashMap et TreeMap. HashMap est le plus utilisé car il offre une complexité en temps constant pour les opérations de base. LinkedHashMap est similaire à HashMap, mais maintient l'ordre d'insertion des éléments. TreeMap est utilisé lorsque vous avez besoin d'un ordre spécifique des éléments en fonction d'une clé.

Il existe également d'autres implémentations de List, Set et Map dans Java, mais les implémentations mentionnées ci-dessus sont les plus courantes et les plus utilisées.

### Les cas d'utilisation 

- Stockage et manipulation de données en mémoire : les collections en Java peuvent être utilisées pour stocker temporairement des données en mémoire, comme une liste de contacts dans une application de carnet d'adresses ou une liste de produits dans une application de commerce électronique.

- Tri et recherche de données : les classes de collection en Java fournissent des méthodes pour trier et rechercher des données en fonction de critères spécifiques, comme le tri d'une liste de noms par ordre alphabétique ou la recherche d'un élément spécifique dans une liste.

- Mise en correspondance des clés et des valeurs : les collections en Java comme Map peuvent être utilisées pour stocker des paires clé-valeur, telles que les données utilisateur dans une application de connexion.


En conclusion, List, Set et Map sont trois types de collections en Java avec des utilisations différentes. List est utile pour stocker des données qui doivent être manipulées dans un ordre précis, Set est utile pour stocker des données uniques qui n'ont pas besoin d'être ordonnées, et Map est utile pour stocker des données qui doivent être récupérées rapidement en utilisant une clé. Chacun de ces types de collections possède des méthodes communes, telles que add(), remove(), size(), etc. qui permettent de manipuler les éléments de la collection.