COURS DE PROGRAMMATION ORIENTEE OBJET : Les collections en Java

Plan Les interfaces Les classes abstraites et concrètes List Set Queue Deque Map Iterator Les classes abstraites et concrètes

Bibliothèque de Collections JAVA La bibliothèque standard de Java fournit des implantations de TAD classiques qu’il suffit ensuite de savoir utiliser de manière adaptée en fonction du problème.

d’interfaces de classes abstraites de mécanismes. Bibliothèque de Collections JAVA Définitions Une collection est un conteneur d’objets Un cadre (framework) définit un certain nombre d’interfaces de classes abstraites de mécanismes.

des classes abstraites pour implanter les collections Bibliothèque de Collections JAVA Définitions La bibliothèque de collections Java constitue un cadre pour des classes de collections. Ce cadre définit des interfaces des classes abstraites pour implanter les collections un protocole d’itération.

Bibliothèque de Collections JAVA Avec le JDK 5.0, les classes et les interfaces sont devenues génériques avec paramètre de type : List<Employe> Avantages : permet d’écrire un code plus sûr (plus de risques de collections hétérogènes) plus facile à lire car plus de transtypage Si on utilise une version antérieure de Java, il faut ignorer les paramètres de type et remplacer les types génériques par le type Object.

Les vieux : Collections du JDK 1.1 Les classes et interfaces suivantes, fournies par le JDK 1.1, Vector HashTable Enumeration existent encore mais il vaut mieux utiliser les nouvelles classes du JDK 1.2 Il est cependant utile de les connaître car elles sont utilisées dans d’autres API du JDK Elles ne seront pas étudiées ici en détails

Petit exemple List<String> l = new ArrayList<String>(); l.add("Pierre Jacques"); l.add("Pierre Paul"); l.add("Jacques Pierre"); l.add("Paul Jacques"); Collections.sort(l); System.out.println(l);

Petit exemple Map<String, Integer> frequences = new HashMap<String, Integer>(); for (String mot : args) { Integer freq = frequences.get(mot); if (freq == null) { freq = 1; } else { freq = freq + 1; } frequences.put(mot, freq); System.out.println(frequences);

COLLECTIONS JAVA Les interfaces Le cadre est composé de 10 interfaces définies dans le paquetage java.util. Il existe deux interfaces fondamentales pour les conteneurs: Collection Map

Les interfaces COLLECTIONS JAVA Collection Queue List Set Deque SortedSet

COLLECTIONS JAVA Les interfaces Map Iterator SortedMap ListIterator

Les interfaces : Collection COLLECTIONS JAVA Les interfaces : Collection public interface Collection<E>{ boolean add (E o); boolean addAll(Collection<? extends E> c); void clear (); boolean contains (Object o); boolean containsAll (Collection<?> c); boolean equals (Object o); int hashCode (); ...

boolean isEmpty(); COLLECTIONS JAVA } Iterator<E> iterator(); boolean remove(Object object); boolean removeAll(Collection<?> c); int size(); Object[] toArray (); }

Les interfaces : Types Joker COLLECTIONS JAVA Les interfaces : Types Joker Collection<? extends E> remplace toute collection générique dont le type est un sous-type de E. Exemple : Collection<? extends CompteBancaire> remplace Collection<CompteCourant> ou Collection<CompteEpargne>. Utilité : On veut pouvoir ajouter une collection d’objets de types CompteCourant à une collection d’objets de type CompteBancaire. Mais Collection <CompteCourant> n’étend pas Collection <CompteBancaire>.

Les interfaces Interface List COLLECTIONS JAVA Permet de manipuler des collections triées. Les éléments sont ajoutés à une position particulière dans le conteneur. Un objet pourra être inséré à une position adéquate indiquée soit par un indice entier par un itérateur de liste

Les interfaces : List COLLECTIONS JAVA Les méthodes supplémentaires interface List<E> extends Collection<E> Les méthodes supplémentaires void add (int index, E element); E get (int index); int indexOf (Object object); ListIterator<E> listIterator (); E remove (int index); E set (int index, E element); List<E> subList (int start, int stop);

Les interfaces COLLECTIONS JAVA Interface Set public interface Set<E> extends Collection<E> Aucune méthode n’est ajoutée en plus. Le comportement des méthodes y est défini de manière plus précise: La méthode add rejette les valeurs doubles. La méthode equals teste si deux ensembles ont les mêmes éléments mais pas nécessairement dans le même ordre.

Les interfaces : Queue COLLECTIONS JAVA public interface Queue<E> extends Collection<E> Collections permettant la gestion des files de type FIFO ou LIFO (piles) et des files de priorités. L’insertion respecte un certain ordre suivant le type de file. Toutes les files définissent l’extraction et la consultation en tête de la file. Supporte les files de capacité restreinte comme les files de capacité illimitée.

Les interfaces COLLECTIONS JAVA Interface Queue Les opérations d’insertion, d’extraction et de consultation sont de deux formes: Elles lèvent des exceptions si l’opération échoue. Elles retourne une valeur spéciale (null ou false) si l’opération échoue. Throws exception Returns special value insertion boolean add(E e) boolean offer(E e) extraction E remove() E poll() consultation E element() E peek()

Les interfaces : Interface Deque (double ended queue) COLLECTIONS JAVA Les interfaces : Interface Deque (double ended queue) public interface Deque<E> extends Queue<E> Collections linéaires qui supportent les insertions et les extractions aux deux extrémités. L’insertion respecte un certain ordre suivant le type de file. Toutes les files définissent l’extraction et la consultation en tête de la file. Supporte les « deques » de capacité restreinte comme les « deques » de capacité illimitée.

Les interfaces : Deque COLLECTIONS JAVA Throws exception Returns special value insertion boolean addFirst(E e) boolean offerFirst (E e) extraction E removeFirst () E pollFirst () consultation E getFirst () E peekFirst () Throws exception Returns special value insertion boolean addLast(E e) boolean offerLast (E e) extraction E removeLast () E pollLast () consultation E getLast () E peekLast ()

Les interfaces : Deque COLLECTIONS JAVA Quand une « deque » est utilisée comme une file, c’est une file de type FIFO qui est gérée: add(e) appelle addLast(e) offer(e) appelle offerLast(e) remove() appelle removeFirst() poll() appelle pollFirst() element() appelle getFirst() peek() appelle peekFirst()

Les interfaces : Deque COLLECTIONS JAVA Une « deque » peut être utilisée comme une Pile en utilisant les méthodes : addFirst(e) removeFirst() getFirst()

Les interfaces : Map public interface Map<K,V>{ COLLECTIONS JAVA int size(); boolean isEmpty(); boolean containsKey(Object key); boolean containsValue(Object value); V get(Object key); V put(K key, V value); boolean equals (Object object); int hashCode(); ...

Les interfaces : Map COLLECTIONS JAVA void clear(); V remove(Object key); void putAll(Map<? extends K,? Extends V> m); Set<K> keySet(); Collection<V> values();

Les interfaces : Map COLLECTIONS JAVA public Set<Map.Entry<K,V>> entrySet(); //retourne un ensemble composé des éléments de la table //Chaque élément retourné est un Map.Entry<K,V> public interface Entry <K,V>{ K getKey(); V getValue(); V setValue(V value); boolean equals(Object o); int hashCode(); }}

Les interfaces COLLECTIONS JAVA Interface Map – Les vues d’une table Une table n’est pas réellement une collection, c’est une collection de paires. Possibilité d’obtenir une vue d’une table, i.e. un objet qui implémente l’interface Collection ou une de ses sous-interface.

Les interfaces : Map – Les vues d’une table COLLECTIONS JAVA Les interfaces : Map – Les vues d’une table Il existe 3 vues différentes : L’ensemble des clés fournie par la méthode public Set<K> keySet(); L’ensemble des valeurs fournie par la méthode public Collection<V> values(); L’ensemble des paires clé/valeur fournie par la méthode public Set<Map.Entry<K,V>> entrySet();

Les interfaces Interfaces SortedSet, SortedMap COLLECTIONS JAVA Les interfaces Interfaces SortedSet, SortedMap Mettent en évidence l’objet de comparaison utilisé pour trier les éléments.

Les interfaces : Iterator – Protocole d’itération Un itérateur est un objet qui parcours une structure de données et passe par chaque élément une seule fois. Plusieurs itérateurs peuvent parcourir la structure simultanément. L’interface Collection<E> possède une méthode public Iterator<E> iterator() qui associe un itérateur à une collection ce qui permet de parcourir la collection.

Les interfaces : Iterator public interface Iterator<E>{ //renvoie true si l’objet de l’itération possède encore au moins un élément public boolean hasNext(); public E next(); public void remove(); }

Les interfaces : Iterator La méthode next : public E next() throws NoSuchElementException En appelant plusieurs fois la méthode next, on peut parcourir tous les éléments de la collection Lorsque la fin de la collection est atteinte, une exception est levée : NoSuchElementException qui dérive de RuntimeException. Il faut donc appeler la méthode hasNext avant la méthode next.

Les interfaces : Iterator La méthode next : Progression d’un itérateur itérateur Élément renvoyé

Les interfaces : Iterator La méthode next : parcours de tous les éléments de type E d’un objet conteneur //création d’un itérateur sur le conteneur Iterator<E> it = conteneur.iterator(); while (it.hasNext()){ E element = it.next(); //utilisation de l’object element }

Les interfaces : Iterator La méthode next : Application : énumération des paires clé/valeur d’un objet table de type Map<K,V> : Set<Map.Entry<K,V>> lesEntrées= table.entrySet(); Iterator<Map.Entry<K,V>> it=lesEntrées.iterator(); while (it.hasNext()){ Map.Entry<K,V> uneEntrée = it.next(); K key = uneEntrée.getKey(); V value = uneEntrée.getValue(); …}

Les interfaces : Iterator La méthode remove throws IllegalStateException Supprime l’élément renvoyé par le dernier appel à next. Obligation d’appeler next avant remove, si on souhaite effacer un élément en fonction de sa position. Iterator<E> it = conteneur.iterator(); it.next(); //passer l’élément it.remove(); //supprimer l’élement

Les interfaces : Iterator Implantation de l’interface Iterator<E> Les itérateurs sont généralement implantés comme des classes internes anonymes définies dans la méthode iterator de la classe de collection associée.

Les interfaces : ListIterator<E> Les interfaces : Iterator Les interfaces : ListIterator<E> La méthode add permet uniquement d’ajouter un object à la fin d’une liste. ListIterator fournit une méthode public void add (E e) qui dépend de la position d’un itérateur et qui permet d’ajouter un objet à un endroit donné dans la liste. Les éléments sont ajoutés avant la position courante de l’itérateur

Les interfaces : ListIterator<E> Les interfaces : Iterator Les interfaces : ListIterator<E> Fournit également deux méthodes permettant de parcourir la liste à l’envers : public boolean hasPrevious() public E previous() et une méthode public void set (E e) permettant de remplacer le dernier élément renvoyé par next ou previous par un nouvel élément.

Interface Iterable<T> Les interfaces : Iterator Interface Iterable<T> Nouvelle interface (depuis JDK 5.0) du paquetage java.lang qui indique qu’un objet peut être parcouru par un itérateur Toute classe qui implémente Iterable peut être parcourue par une boucle « for each » L’interface Collection en hérite

Boucle « for each » Les interfaces : Iterator Boucle « normale » : for(Iterator<Employe> it = coll.iterator(); it.hasNext(); ) { Employe e = it.next(); String nom = e.getNom(); } Avec une boucle « for each » : for (Employe e : coll) {

Classes abstraites et concrètes

Les classes abstraites COLLECTIONS JAVA Les classes abstraites AbstractCollection<E> qui implémente Collection<E>, AbstractList<E> qui implémente List<E>, AbstractSequentialList<E> qui implémente List<E>, AbstractSet<E> qui implémente Set<E>, AbstractQueue<E> qui implémente Queue<E>, AbstractMap<E> qui implémente Map<E>.

Les classes abstraites COLLECTIONS JAVA Les classes abstraites Ces classes sont abstraites car elles n’implémentent pas le corps de toutes les méthodes de l’interface. Les méthodes iterator, size sont des méthodes abstraites qui seront définies dans les classes concrètes car elle dépendent de la structure de données choisie pour implanter le conteneur.

Les classes abstraites COLLECTIONS JAVA Les classes abstraites Les classes abstraites définissent le corps des autres méthodes en faisant appel aux méthodes abstraites , en particulier à la méthode iterator.

Les classes abstraites COLLECTIONS JAVA Les classes abstraites Exemple : Implémentation de la méthode toString dans la classe AbstractCollection public String toString(){ if (isEmpty()) return " [ ] "; Iteraror<E> it = iterator(); String str = " [ " + it.next(); while (it.hasNext()) str = str + " , " + it.next(); return str + " ] " ;

Les classes concrètes COLLECTIONS JAVA Une classe concrète étend une classe abstraite et fournit les implémentations des méthodes abstraites comme iterator et size. Elle peut aussi redéfinir les autres méthodes si nécessaire.

Il existe de nombreux cas particuliers de collections ; par exemple Méthode Optionnelle Il existe de nombreux cas particuliers de collections ; par exemple collections de taille fixe, collections dont on ne peut enlever des objets Plutôt que de fournir une interface pour chaque cas particulier, l’API sur les collections comporte la notion de méthode optionnelle.

Méthode Optionnelle Méthode qui peut renvoyer une java.lang.UnsupportedOperationException (sous-classe de RuntimeException) dans une classe d'implantation qui ne la supporte pas Les méthodes optionnelles renvoient cette exception dans les classes abstraites du paquetage Exemple d’utilisation : si on veut écrire une classe pour des listes non modifiables, on ne redéfinit pas les méthodes set, add et remove de la classe abstraite AbstractList

Classes des collections

En + : Classes utilitaires Collections (avec un s final) fournit des méthodes static pour, en particulier, trier une collection faire des recherches rapides dans une collection triée Arrays fournit des méthodes static pour, en particulier, trier faire des recherches rapides dans un tableau trié transformer un tableau en liste

Les classes concrètes COLLECTIONS JAVA AbstractCollection<E> AbstractList<E> ArrayList<E> List<E> AbstractSequentialList<E> LinkedList<E> Deque<E>

Les classes concrètes COLLECTIONS JAVA AbstractCollection<E> ArrayQueue<E> Collection<E> Deque<E> AbstractQueue<E> PriorityQueue<E> Queue<E>

Les classes concrètes COLLECTIONS JAVA AbstractCollection<E> HashSet<E> AbstractSet<E> Set<E> TreeSet<E>

AbstractMap<K,V> COLLECTIONS JAVA Les classes concrètes HashMap<K,V> AbstractMap<K,V> Map<K,V> TreeMap<K,V>

Dictionary<K,V> COLLECTIONS JAVA Les classes concrètes La bibliothèque a intégré au cadre des collections des classes de conteneur plus anciennes. AbstractList<E> Dictionary<K,V> Vector<E> Hashtable<K,V> Stack<E> Properties

COLLECTIONS JAVA La classe AbstractCollection<E> est une implantation partielle de l’interface Collection<E> sans spécification de la structure de stockage utilisée pour le conteneur.

On a présenté deux structures de données pour implanter les listes: COLLECTIONS JAVA On a présenté deux structures de données pour implanter les listes: Tableaux Accès aléatoire immédiat : O(1). Insertions et suppressions nécessitant un certain nombre de transferts de données : O(n). Listes chaînées Insertions et suppressions en O(1). Accès aléatoire en O(n) car pas d’utilisation d’index.

Les classes abstraites implantant l’interface List<E> : COLLECTIONS JAVA Les classes abstraites implantant l’interface List<E> : AbstractList<E> AbstractSequentialList<E>

La classe AbstractList<E> COLLECTIONS JAVA La classe AbstractList<E> C’est une implantation partielle de l’interface List<E>. Elle fournit l’ossature des implantations complètes de l’interface List<E> qui ont recours à un tableau pour stocker les éléments de la liste. la méthode get est déclarée abstraite et devra être implantée par les classes dérivées.

La classe AbstractList<E> COLLECTIONS JAVA La classe AbstractList<E> Les méthodes set, add et remove sont implantées de la manière suivante: { throw new UnsupportedOperationException(); } Elles sont facultatives et pourront être implantées par les classes dérivées si la structure de données les rend efficaces.

La classe AbstractSequentialList<E> COLLECTIONS JAVA La classe AbstractSequentialList<E> étend la classe AbstractList<E>. fournit l’ossature des implantations complètes de l’interface List qui ont recours à une structure chaînée pour stocker les éléments de la liste.

Les classes concrètes dérivées: COLLECTIONS JAVA Les classes concrètes dérivées: ArrayList<E> LinkedList<E>

La classe ArrayList<E> COLLECTIONS JAVA La classe ArrayList<E> Classe dérivée de la classe AbstractList<E> utilise un tableau dynamique relogeable.

La classe ArrayList<E> APPLICATION La classe ArrayList<E> Application : On souhaite implanter le type abstrait de données multi-ensemble. Un multi-ensemble est une collection d’éléments susceptible de contenir des copies. Les opérations définies pour ce TAD sont les mêmes que celles définies dans l’interface Collection. Il faut redéfinir la méthode equals sachant que deux multi-ensembles seront égaux s'ils contiennent les mêmes éléments le même nombre de fois.

APPLICATION public class SacGeneric<E> extends AbtractCollection<E>{ private List<E> sac; public SacGeneric(){ sac = new ArrayList<E>(); } public boolean add(E e) { return sac.add(e);

APPLICATION public Iterator<E> iterator() { return sac.iterator(); } public int size() { return sac.size(); public boolean equals(Object o){ if (o==this) return true; if (o==null) return false; if (o.getClass()!= this.getClass()) return false; //getClass teste SacGeneric mais pas le type E

APPLICATION SacGeneric<?> s= (SacGeneric<?>)o; if (s.size() != this.size())return false; if (!s.containsAll(this)) return false; if (!this.containsAll(s)) return false; Iterator<?> it = this.iterator(); while (it.hasNext()){ Object e = it.next(); if (frequence(e)!= s.frequence(e)) return false; } return true; }//fin méthode equals

APPLICATION private int frequence (Object o){ int compteur=0; Iterator<E> it=iterator(); while (it.hasNext()) if (o.equals(it.next())) compteur++; return compteur; }

Implantation de l’interface LIST La classe LinkedList<E> Classe dérivée de la classe AbstractSequentialList<E> utilise une liste chaînée.

La classe LinkedList<E> Implantation de l’interface LIST La classe LinkedList<E> Applications : 1 - Proposer une méthode pour fusionner les éléments d’une liste chaînée l2 dans une liste chaînée l1 . Ex : à partir de l1 = [a1, a2, a3] et l2 = [b1, b2, b3, b4] , on obtient l1= [a1, b1, a2, b2, a3, b3, b4] et l2 = []. 2 - Supprimer un mot sur deux dans une liste chaînée.

La classe LinkedList<E> 1 – Implantation de l’interface LIST La classe LinkedList<E> 1 – public static void fusionner(LinkedList<E> l1, LinkedList<E> l2) { ListIterator<E> it1 = l1.listIterator(); ListIterator<E> it2 = l2.listIterator(); while (it1.hasNext() && it2.hasNext()){ it1.next(); it1.add(it2.next()); it2.remove(); }

La classe LinkedList<E> 1 – Implantation de l’interface LIST La classe LinkedList<E> 1 – if (it2.hasNext()){ l1.addAll(l2); l2.clear(); }

Implantation de l’interface LIST La classe LinkedList<E> 2 - public static void supprime(LinkedList<E> l){ ListIterator<E> it= l.listIterator(); while (it.hasNext()){ it.next(); if (it.hasNext()){ it.remove(); }

Implantation de l’interface QUEUE La classe abstraite AbstractQueue<E> implante partiellement l’interface Queue<E>. Il existe plusieurs classes concrètes permettant de réaliser différents types de files et en particulier PriorityQueue

La classe PriorityQueue<E> Implantation de l’interface QUEUE La classe PriorityQueue<E> Implémente l’interface Queue<E> en utilisant un tas. Les éléments doivent être des instances d’une classe qui implémente l’interface Comparable<T>. Les éléments sont ordonnés suivant l’ordre défini par la méthode int compareTo (T o) ou par un Comparator fourni dans le constructeur de la file de priorité.

L’interface Deque<E> est implémentée par deux classes concrètes: Implantation de l’interface DEQUE L’interface Deque<E> est implémentée par deux classes concrètes: ArrayDeque<E> Linkedlist<E> }

La classe ArrayDeque<E> Implantation de l’interface DEQUE La classe ArrayDeque<E> Classe dérivée de la classe AbstractCollection<E> utilise un tableau dynamique relogeable. Cette classe est en moyenne plus rapide que la classe Stack quand elle est utilisée comme une pile et plus rapide que LinkedList quand elle est utilisée comme une file.

La classe LinkedList<E> Implantation de l’interface DEQUE La classe LinkedList<E> En plus d’implémenter l’interface List, cette classe implémente l’interface Deque. LinkedList peut être utilisée pour implanter les files à double extrémité, en particulier les piles et les files.

Il existe deux classes concrètes: Implantation de l’interface SET La classe abstraite AbstractSet<E> implante partiellement l’interface Set<E>. Il existe deux classes concrètes: HashSet<E> et TreeSet<E>.

La classe HashSet<E> Implantation de l’interface SET La classe HashSet<E> Implante l’interface Set<E> à partir d’une table de hachage définie avec une capacité initiale de 101. Utilise les valeurs fournies par la méthode hashCode des objets pour les stocker dans la table de hachage.

La classe HashSet<E> Implantation de l’interface SET La classe HashSet<E> Les collisions sont gérées par hachage ouvert. Pour éviter au maximum les collisions, il faut que le nombre d’éléments de la table soit très inférieur à sa capacité. Le rapport entre ces deux paramètres est le facteur de charge. Une valeur plafond peut être définie au moment de la création de la table, par défaut : 75%. La table est redimensionnée automatiquement quand le facteur de charge atteint la valeur plafond spécifiée.

La classe TreeSet<E> Implantation de l’interface SET La classe TreeSet<E> Implémente l’interface SortedSet<E>. TreeSet<E> stocke ses objets dans un arbre binaire de recherche équilibré (arbre rouge et noir). L’accès à ses éléments (add, contains, remove) est exécuté en O(log(n)). Avantage : éléments triés

La classe TreeSet<E> Implantation de l’interface SET La classe TreeSet<E> public class TreeSet<E> extends AbstractSet<E> implements SortedSet<E> { … //constructeur particulier : <? super E> limite aux supertypes de E public TreeSet(Comparator<?super E> comparator); //méthodes requises par l’interface SortedSet public Comparator<? super E> comparator(); public E first(); public E last(); public SortedSet<E> subSet(E fromElement, E toElement); }

La classe TreeSet<E> Implantation de l’interface SET La classe TreeSet<E> Comparaison des éléments: Par défaut, TreeSet<E> suppose que les éléments insérés sont comparables et implémentent l’interface Comparable<E>.

Implantation de l’interface SET La classe TreeSet<E> Comparaison des éléments: Si on souhaite pouvoir utiliser une autre méthode de comparaison (les éléments implémentent déjà l’interface Comparable), on appelle le constructeur public TreeSet (Comparator<? super E> comparator) en passant un objet Comparator<? super E> en paramètre. Comparator<T> est une interface qui possède une seule méthode public int compare( T o1, T o2).

La classe TreeSet<E> Implantation de l’interface SET La classe TreeSet<E> Etant donné un type E et un supertype T, pour comparer des éléments suivant un critère précis: Définir une classe EltComparator qui implémente l’interface Comparator<T>. Créer un object instance de cette classe: EltComparator comp = new EltComparator(); Appeler le constructeur de TreeSet en passant cet object en paramètre: TreeSet<E> t = new TreeSet(comp);

Implantation de l’interface SET La classe TreeSet<E> Application à la gestion des comptes bancaires: On souhaite créer une classe AgenceBancaire permettant de gérer un ensemble de comptes bancaires. On souhaite pouvoir ajouter un compte, s’il n’existe pas, supprimer un compte, rechercher un compte par le nom du client, afficher l’état de tous les comptes… Les comptes doivent être triés par leur numéro.

La classe TreeSet<E> Implantation de l’interface SET La classe TreeSet<E> import java.util.*; public class AgenceBancaire { private Set<CompteBancaire> lesComptes; public AgenceBancaire () { lesComptes = new TreeSet<CompteBancaire>(); }

Implantation de l’interface SET public boolean ajouterCompte(CompteBancaire c) { return lesComptes.add(c); } public void supprimerCompte(CompteBancaire c) lesComptes.remove(c); public String toString() { return lesComptes.toString();

Implantation de l’interface SET public void traitementQuotidien(){ Iterator<CompteBancaire> it = lesComptes.iterator(); while (it.hasNext()){ CompteBancaire c= it.next(); c.traitementQuotidien(); } System.out.println("Traitement Quotidien effectué");

Implantation de l’interface SET public CompteBancaire rechercherCompte(String nom,String type){ CompteBancaire c=null; Iterator<CompteBancaire> it = lesComptes.iterator(); while (it.hasNext()){ c=it.next(); if (type.equals(c.type) && nom.equalsIgnoreCase(c.getNom()) ) return c; } return null; }//fin de la classe

Implantation de l’interface MAP La classe abstraite AbstractMap<K,V> implante partiellement l’interface Map<K,V>. Il existe deux classes concrètes principales: HashMap<K,V> TreeMap<K,V> Deux autres classes concrètes: WeakHashMap<K,V> ( gère les clés qui ne sont plus utilisées). LinkedHashMap<K,V> (garde une trace de l’ordre d’insertion).

Implantation de l’interface MAP La classe HashMap<K,V> Comme HashSet<K,V>, HashMap<K,V> implante l’interface Map<K,V> à partir d’une table de hachage.

Implantation de l’interface MAP La classe TreeMap<K,V> Implémente l’interface SortedMap<K,VE>. TreeMap<K,V> stocke ses objets dans un arbre binaire de recherche équilibré (arbre rouge et noir). L’accès à ses éléments (add, contains, remove) est exécuté en O(log(n)). Avantage : éléments triés.

La classe TreeMap<K,V> Implantation de l’interface MAP La classe TreeMap<K,V> Application à la gestion des comptes bancaires: Etant donné qu’un numéro identifie un compte, on souhaite gérer les couples (numéro, compte) de manière à pouvoir rechercher ou supprimer un compte à partir de son numéro.

Map : exemple Map<String,Employe> hm = new HashMap<String,Employe> (); Employe e = new Employe("Dupond"); e.setMatricule("E125"); hm.put(e.getMatricule(), e); // Crée et ajoute les autres employés dans la table de hachage . . Employe e2 = hm.get("E369"); Collection<Employe> elements = hm.values(); for (Employe employe : employes) { System.out.println(employe.getNom()); }

La classe TreeMap Map : exemple Compte import java.util.*; public class AgenceBancaireBis { private Map<Integer,CompteBancaire> lesComptes; public AgenceBancaireBis() { lesComptes = new TreeMap<Integer,CompteBancaire>(); }

Map : exemple Compte public void ajouterCompte(CompteBancaire c){ lesComptes.put(c.getNumero(), c); } //rechercher un compte à partir du numero public CompteBancaire rechercherCompte( int numero){ return lesComptes.get(numero); public void supprimerCompte(int numero) { lesComptes.remove(numero); public String toString(){ return lesComptes.toString();

Map : exemple Compte public void traitementQuotidien(){ Collection<CompteBancaire> c = lesComptes.values(); Iterator<CompteBancaire> it = c.iterator(); while (it.hasNext()){ CompteBancaire compte= it.next(); compte.traitementQuotidien(); } System.out.println("traitement quotidien effectué");

Collections et types primitifs Les collections de java.util ne peuvent contenir de valeurs des types primitifs Avant le JDK 5, il fallait donc utiliser explicitement les classes enveloppantes des types primitifs, Integer par exemple A partir du JDK 5, les conversions entre les types primitifs et les classes enveloppantes peuvent être implicite avec le « boxing » / « unboxing »

Collections et types primitifs List<Integer> l = new ArrayList<Integer>(); l.add(new Integer(10)); l.add(new Integer(-678)); l.add(new Integer(87)); l.add(new Integer(7)); int i = l.get(0).intValue();

Collections et types primitifs List<Integer> l = new ArrayList<Integer>(); l.add(10); l.add(-678); l.add(87); l.add(7); int i = l.get(0);