Collections génériques
API pour les collections
* En standard, de nombreuses collections
* Package "java.util"
* Ensembles: Set, SortedSet, HashSet, TreeSet
* Listes: List, ArrayList, Vector, LinkedList
* Files d'attente: Queue, PriorityQueue
* Associations: Map, SortedMap, HashMap, TreeMap
* Avant Java 1.5
* Pas de collections avec généricité
* Collections d'objets hétérogènes
* Contiennent des "Object"
* Downcast indispensable à l'extraction
* Depuis Java 1.5
* Collections avec généricité
* Collections d'objets homogènes
* Compatibilité entre les deux versions
* Avec le "type erasure": classe générique ==> classe normale
* Ancienne classe (< Java 1.5) ~ classe obtenue par "type erasure"
* Différence: généricité ==> contrôles de type à la compilation
Hiérarchie des collections
* Deux interfaces racines
* Collection: collections classiques
* Map: collections associatives
Interface "Collection"
* Opérations d'ajout
* add(:T) : boolean
* addAll(:Collection<? extends T>) : boolean
* Opérations de suppression
* clear()
* remove(:Object) : boolean
* removeAll(:Collection<? extends T>) : boolean
* retainAll(:Collection<? extends T>) : boolean
* Opérations de consultation
* contains(:Object) : boolean
* containsAll(:Collection<? extends T>) : boolean
* isEmpty() : boolean
* size() : int
* Conversion en tableau
* toArray() : Object[]
* <U> toArray(:U[]) : U[]
Les itérateurs
* Pour parcourir une collection: l'itérateur
* Pointe sur un élément d'une collection
* Permet de passer d'un élément à un autre
* Plusieurs itérateurs ==> parcours simultanés
* API indépendante de la véritable structure de données
* "Collection" implémente l'interface "Iterable"
* Peut fournir des itérateurs sur l'ensemble de ses éléments
* Méthode: iterator() : Iterator<T>
Boucle "for" évoluée
* Boucle "for" classique
void afficher(Collection<String> c) {
Iterator<String> i = c.iterator();

while (i.hasNext())
System.out.println(i.next());
}
* Boucle "for" évoluée
void afficher(Collection<String> c) {
for (String e : c) System.out.println(e);
}
* for (variable : collection)
* A partir de Java 1.5
* variable = élément parcouru à une itération donnée
* collection = une collection d'objets "itérable"
* Soit un tableau classique
* Soit un objet qui implémente l'interface "Iterable"
Interface "List"
* Dans une liste, les éléments sont indexés
* Méthodes spécifiques
* add(:int,:T)
* get(:int) : T
* indexOf(:Object) : int
* lastIndexOf(:Object) : int
* remove(:int) : T
* set(:int,:T) : T
* subList(:int,:int) : List<T>
* Implémentations
* ArrayList / Vector: tableau auto-ajustable
* LinkedList: liste chaînée
Interfaces "Set" et "SortedSet"
* L'ensemble est l'implémentation directe de la collection
* L'interface "Set" n'a donc aucune méthode spécifique
* Implémentation: HashSet
* Ensemble trié: interface "SortedSet"
* first() : T
* last() : T
* headSet(:T) : SortedSet<T>
* tailSet(:T) : SortedSet<T>
* subSet(:T,:T) : SortedSet<T>
Collections triées
* Pour trier des éléments, il faut pouvoir les comparer
* Soit ils implémentent l'interface "Comparable"
* Solution retenue avec une construction par défaut
* s = new SortedSet<String>();
* Soit la collection possède un objet tiers de type "Comparator"
* Comparateur fourni à la construction
* s = new SortedSet<String>(new MonComparateur());
Interface "Map" (1/2)
* Contient des couples clé-valeur
* Deux types paramètres
* Map<K,T>
* Opérations d'ajout
* put(:K,:T) : T
* putAll(:Map<? extends K,? extends T>)
* Opérations de suppression
* clear()
* remove(:Object) : T
* Opérations de consultation
* containsKey(:Object) : boolean
* containsValue(:Object) : boolean
* isEmpty() : boolean
* size() : int
* get(:Object) : T
Interface "Map" (2/2)
* Type associé au couple clé-valeur
* Map.Entry<K,T>
* Méthodes: getKey(), getValue() et setValue(:T)
* Parcours des éléments ==> extraction d'une "vue"
* Liste des couples: entrySet() : Set<Map.Entry<K,T> >
* Liste des clés: keySet() : Set<K>
* Liste des éléments: values() : Collection<T>
* Collection triée: sous-interface "SortedMap"
* Similaire à "SortedSet"
* Tri sur les clés et non sur les valeurs
* Avec "Comparable" ou "Comparator"
* Implémentations
* HashMap: non triée
* TreeMap: triée