Référence des collections
La Référence des collections en Java constitue un élément fondamental pour tout développeur backend travaillant sur des applications complexes et des architectures systèmes robustes. Elle fournit un cadre complet pour la gestion de données groupées, incluant les interfaces abstraites et les implémentations concrètes telles que List, Set, Queue et Map. L’importance de cette référence réside dans sa capacité à permettre une manipulation efficace et sécurisée des collections, en minimisant les risques de fuites de mémoire et en optimisant les performances algorithmiques.
Dans le développement logiciel et l’architecture des systèmes, les collections sont utilisées pour gérer les sessions utilisateurs, le caching, les files de traitement et la synchronisation entre threads. Les concepts clés comprennent la syntaxe Java, les structures de données (tableaux dynamiques, listes chaînées, tables de hachage, arbres rouges-noirs), les algorithmes de tri et de recherche, ainsi que les principes de programmation orientée objet tels que l’encapsulation, le polymorphisme et l’abstraction. À travers cette référence, le lecteur apprendra à créer, manipuler et optimiser les collections, appliquer des algorithmes avancés, gérer les exceptions correctement et adopter des pratiques de codage sûres et performantes.
Exemple de Base
javaimport java.util.ArrayList;
import java.util.List;
public class BasicCollectionsExample {
public static void main(String\[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
for (Integer num : numbers) {
System.out.println("Number: " + num);
}
System.out.println("Premier élément: " + numbers.get(0));
numbers.remove(Integer.valueOf(20));
System.out.println("Taille de la liste: " + numbers.size());
System.out.println("Contenu de la liste: " + numbers);
}
}
Exemple Pratique
javaimport java.util.*;
class Produit {
private String nom;
private double prix;
public Produit(String nom, double prix) {
this.nom = nom;
this.prix = prix;
}
public String getNom() { return nom; }
public double getPrix() { return prix; }
@Override
public String toString() {
return nom + " (€" + prix + ")";
}
}
public class CollectionsPracticalExample {
public static void main(String\[] args) {
Set<Produit> produits = new TreeSet<>(Comparator.comparingDouble(Produit::getPrix));
produits.add(new Produit("Ordinateur", 1200.50));
produits.add(new Produit("Téléphone", 799.99));
produits.add(new Produit("Tablette", 450.00));
System.out.println("Produits triés par prix:");
produits.forEach(System.out::println);
double seuil = 500.0;
List<Produit> produitsChers = produits.stream()
.filter(p -> p.getPrix() > seuil)
.toList();
System.out.println("Produits chers:");
produitsChers.forEach(System.out::println);
}
}
Advanced Implementation
javaimport java.util.*;
import java.util.concurrent.ConcurrentHashMap;
public class AdvancedCollectionsExample {
public static void main(String\[] args) {
Map\<String, List<String>> rolesUtilisateurs = new ConcurrentHashMap<>();
rolesUtilisateurs.put("alice", new ArrayList<>(Arrays.asList("admin", "editor")));
rolesUtilisateurs.put("bob", new ArrayList<>(Arrays.asList("viewer")));
rolesUtilisateurs.put("charlie", new ArrayList<>());
rolesUtilisateurs.computeIfAbsent("charlie", k -> new ArrayList<>()).add("editor");
rolesUtilisateurs.forEach((user, roles) -> {
System.out.println(user + " rôles: " + roles);
});
try {
List<String> roles = rolesUtilisateurs.get("dave");
if (roles != null) {
System.out.println("Rôles de Dave: " + roles);
} else {
System.out.println("Utilisateur dave non trouvé.");
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
📊 Référence Complète
Property/Method | Description | Syntax | Example | Notes |
---|---|---|---|---|
add(E e) | Ajoute un élément | collection.add(element) | numbers.add(10) | Pour List et Set |
remove(Object o) | Supprime un élément par valeur | collection.remove(element) | numbers.remove(Integer.valueOf(20)) | Évite les confusions d’index |
get(int index) | Accès par index | list.get(index) | numbers.get(0) | List uniquement |
size() | Taille de la collection | collection.size() | numbers.size() | Général |
isEmpty() | Vérifie si vide | collection.isEmpty() | numbers.isEmpty() | Sécurité des boucles |
contains(Object o) | Vérifie existence | collection.contains(element) | numbers.contains(30) | Recherche linéaire dans List |
clear() | Vide la collection | collection.clear() | numbers.clear() | Évite fuites mémoire |
iterator() | Obtient un Iterator | Iterator<E> it = collection.iterator() | Iterator<Integer> it = numbers.iterator() | Parcours avancé |
forEach(Consumer<? super E> action) | Parcours avec lambda | collection.forEach(e -> ...) | numbers.forEach(System.out::println) | Programmation fonctionnelle |
toArray() | Convertit en tableau | collection.toArray() | Object[] arr = numbers.toArray() | Compatibilité API ancienne |
stream() | Crée un Stream | collection.stream() | numbers.stream().filter(n -> n>10) | Traitement parallèle possible |
parallelStream() | Stream parallèle | collection.parallelStream() | numbers.parallelStream().forEach(...) | Optimisation performances |
addAll(Collection<? extends E> c) | Ajout multiple | collection.addAll(other) | numbers.addAll(otherList) | Ajout en lot |
removeAll(Collection<?> c) | Supprime multiples | collection.removeAll(other) | numbers.removeAll(toRemove) | Filtrage de données |
retainAll(Collection<?> c) | Conserve intersection | collection.retainAll(other) | numbers.retainAll(toKeep) | Inverse de removeAll |
equals(Object o) | Compare collections | collection.equals(other) | numbers.equals(otherNumbers) | List sensible à l’ordre |
hashCode() | Code de hachage | collection.hashCode() | int hash = numbers.hashCode() | Important pour Map et Set |
addFirst(E e) | Ajoute au début | linkedList.addFirst(e) | linkedList.addFirst(5) | LinkedList uniquement |
addLast(E e) | Ajoute à la fin | linkedList.addLast(e) | linkedList.addLast(10) | LinkedList uniquement |
getFirst() | Premier élément | linkedList.getFirst() | linkedList.getFirst() | LinkedList uniquement |
getLast() | Dernier élément | linkedList.getLast() | linkedList.getLast() | LinkedList uniquement |
offer(E e) | Ajoute à Queue | queue.offer(e) | queue.offer(15) | Retourne false si plein |
poll() | Retire tête Queue | queue.poll() | Integer head = queue.poll() | Retourne null si vide |
peek() | Lit tête Queue | queue.peek() | Integer head = queue.peek() | Retourne null si vide |
push(E e) | Empile Stack | stack.push(e) | stack.push(20) | Stack uniquement |
pop() | Dépile Stack | stack.pop() | Integer top = stack.pop() | Exception si vide |
peek() | Lit Stack | stack.peek() | Integer top = stack.peek() | Stack uniquement |
computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) | Créé si absent | map.computeIfAbsent(key, k -> new ArrayList<>()) | userRoles.computeIfAbsent("dave", k -> new ArrayList<>()) | Initialisation automatique |
put(K key, V value) | Ajoute paire clé/valeur | map.put(key,value) | map.put("alice", list) | Map uniquement |
get(Object key) | Récupère valeur | map.get(key) | map.get("alice") | Retourne null si absent |
remove(Object key) | Supprime entrée | map.remove(key) | map.remove("bob") | Map uniquement |
keySet() | Récupère clés | map.keySet() | Set<String> keys = map.keySet() | Pour itération |
values() | Récupère valeurs | map.values() | Collection<List<String>> vals = map.values() | Pour itération |
entrySet() | Récupère entrées | map.entrySet() | Set<Map.Entry<String,List<String>>> entries = map.entrySet() | Itération avancée |
merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) | Fusionne valeurs | map.merge("alice", newList, (oldV,newV)->oldV.addAll(newV)) | Fusion efficace | Évite écrasement |
replace(K key, V value) | Remplace valeur | map.replace("alice", newList) | Mise à jour Map | Retourne null si clé absente |
replaceAll(BiFunction<? super K,? super V,? extends V> function) | Mise à jour globale | map.replaceAll((k,v)->v) | Modification en lot | Programmation fonctionnelle |
Collections.sort(List<T> list) | Tri liste | Collections.sort(list) | Collections.sort(numbers) | Tri interne |
Collections.reverse(List<?> list) | Inverse liste | Collections.reverse(list) | Collections.reverse(numbers) | Aide aux algos |
Collections.shuffle(List<?> list) | Mélange aléatoire | Collections.shuffle(list) | Collections.shuffle(numbers) | Aléatoire |
Collections.unmodifiableList(List<? extends T> list) | Liste immuable | List<Integer> unmod = Collections.unmodifiableList(numbers) | Protection modification | Sécurité |
Collections.synchronizedList(List<T> list) | Liste thread-safe | List<Integer> syncList = Collections.synchronizedList(numbers) | Multi-thread | Synchronisation nécessaire |
Collections.binarySearch(List<? extends Comparable<? super T>> list, T key) | Recherche binaire | int idx = Collections.binarySearch(numbers, 20) | Liste triée | O(log n) |
Collections.frequency(Collection<?> c, Object o) | Nombre occurrences | Collections.frequency(numbers, 10) | Analyse données | O(n) |
Collections.max(Collection<? extends T> c) | Valeur max | Collections.max(numbers) | Comparable nécessaire | Algo fréquent |
Collections.min(Collection<? extends T> c) | Valeur min | Collections.min(numbers) | Comparable nécessaire | Algo fréquent |
Collections.addAll(Collection<? super T> c, T... elements) | Ajout multiple | Collections.addAll(numbers, 1,2,3) | Réduit boucles | Efficace |
Collections.copy(List<? super T> dest, List<? extends T> src) | Copie liste | Collections.copy(dest, src) | dest.size() >= src.size() | Évite IndexOutOfBounds |
Collections.rotate(List<?> list, int distance) | Rotation | Collections.rotate(numbers, 2) | Algorithme circulaire | Déplacement circulaire |
Collections.fill(List<? super T> list, T obj) | Remplir liste | Collections.fill(numbers, 0) | Initialisation | Remplace tout |
Collections.nCopies(int n, T obj) | Liste immuable | List<Integer> zeros = Collections.nCopies(5,0) | Lecture seule | Taille fixe |
Collections.disjoint(Collection<?> c1, Collection\<?> c2) | Pas d’éléments communs | Collections.disjoint(list1,list2) | Boolean | Vérification |
Collections.emptyList() | Liste vide | Collections.emptyList() | List<Integer> empty = Collections.emptyList() | Immuable |
Collections.emptySet() | Set vide | Collections.emptySet() | Set<String> emptySet = Collections.emptySet() | Immuable |
Collections.emptyMap() | Map vide | Collections.emptyMap() | Map\<String,Integer> emptyMap = Collections.emptyMap() | Immuable |
Collections.singleton(T o) | Set à un élément | Collections.singleton(1) | Immuable | Fixe |
Collections.singletonList(T o) | Liste à un élément | Collections.singletonList("one") | Immuable | Thread-safe |
Collections.singletonMap(K key, V value) | Map à un élément | Collections.singletonMap("k","v") | Immuable | Thread-safe |
📊 Complete Properties Reference
Property | Values | Default | Description | Browser Support |
---|---|---|---|---|
ArrayList | Tableau dynamique | Vide | Liste modifiable | Toutes JVM |
LinkedList | Liste doublement chaînée | Vide | Insertion/suppression efficace | Toutes JVM |
HashSet | Set haché | Vide | Éléments uniques et non ordonnés | Toutes JVM |
TreeSet | Arbre rouge-noir | Vide | Éléments uniques et triés | Toutes JVM |
HashMap | Map hachée | Vide | Accès clé/valeur rapide | Toutes JVM |
TreeMap | Map arbre rouge-noir | Vide | Clés triées | Toutes JVM |
ConcurrentHashMap | Map concurrente | Vide | Thread-safe | Toutes JVM |
Stack | Pile | Vide | LIFO | Toutes JVM |
Queue | File | Vide | FIFO | Toutes JVM |
PriorityQueue | File prioritaire | Vide | Tri par priorité | Toutes JVM |
Vector | Tableau synchronisé | Vide | Ancien, thread-safe | Toutes JVM |
Collections.unmodifiableList | Liste immuable | N/A | Protection modification | Toutes JVM |
La maîtrise des collections Java permet de gérer efficacement les données, d’implémenter des algorithmes complexes et de construire des systèmes backend fiables. Les types incluent List, Set, Map et Queue, et le choix du type approprié influence directement la performance et la sécurité. L’usage avancé implique tri, filtrage, collections immuables, synchronisation et intégration avec Stream API, crucial pour les applications d’entreprise. Les étapes suivantes consistent à explorer les collections concurrentes, les implémentations spécialisées comme LinkedHashMap et WeakHashMap, et la combinaison avec la programmation fonctionnelle. Pour appliquer ces concepts, sélectionnez toujours la collection adaptée, évitez les fuites mémoire et optimisez les accès. Les ressources incluent la documentation officielle Java, tutoriels avancés et projets open source, fournissant un apprentissage continu et des cas pratiques.
🧠 Testez Vos Connaissances
Testez vos Connaissances
Testez votre compréhension de ce sujet avec des questions pratiques.
📝 Instructions
- Lisez chaque question attentivement
- Sélectionnez la meilleure réponse pour chaque question
- Vous pouvez refaire le quiz autant de fois que vous le souhaitez
- Votre progression sera affichée en haut