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
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
Latest comments (0)