1 COURS DE PROGRAMMATION ORIENTEE OBJET : Les collections en Java.
-
Upload
alard-morand -
Category
Documents
-
view
134 -
download
0
Transcript of 1 COURS DE PROGRAMMATION ORIENTEE OBJET : Les collections en Java.
1
COURS DE PROGRAMMATION ORIENTEE OBJET :
Les collections en Java
2
Plan Les interfaces
– List– Set– Queue– Deque– Map– Iterator
Les classes abstraites et concrètes
3
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.
4
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.
Bibliothèque de Collections JAVA
5
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
6
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.
Bibliothèque de Collections JAVA
7
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
Les vieux : Collections du JDK 1.1
8
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
9
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);
Petit exemple
10
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
11
Les interfaces
SortedSet
Collection
SetListQueue
Deque
COLLECTIONS JAVA
12
Les interfaces
SortedMap
Map
ListIterator
Iterator
COLLECTIONS JAVA
13
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 ();
...
COLLECTIONS JAVA
14
boolean isEmpty(); Iterator<E> iterator(); boolean remove(Object object); boolean removeAll(Collection<?> c); int size(); Object[] toArray ();
}
COLLECTIONS JAVA
15
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>.
COLLECTIONS JAVA
16
Les interfaces–Interface List
• 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
COLLECTIONS JAVA
17
Les interfaces : Listinterface List<E> extends Collection<E>
– Les méthodes supplémentairesvoid 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);
COLLECTIONS JAVA
18
Les interfaces– 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.
COLLECTIONS JAVA
19
Les interfaces : Queuepublic 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.
COLLECTIONS JAVA
20
Les interfaces– 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 valueinsertion boolean add(E e) boolean offer(E e)
extraction E remove() E poll()consultation E element() E peek()
COLLECTIONS JAVA
21
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.
COLLECTIONS JAVA
22
Les interfaces : DequeThrows 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 valueinsertion boolean addLast(E e) boolean offerLast (E e)
extraction E removeLast () E pollLast ()consultation E getLast () E peekLast ()
COLLECTIONS JAVA
23
Les interfaces : Deque• 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()
COLLECTIONS JAVA
24
Les interfaces : Deque• Une « deque » peut être utilisée comme
une Pile en utilisant les méthodes :–addFirst(e)–removeFirst()–getFirst()
COLLECTIONS JAVA
25
Les interfaces : Mappublic interface Map<K,V>{ 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();
...
COLLECTIONS JAVA
26
Les interfaces : Map
void clear(); V remove(Object key); void putAll(Map<? extends K,? Extends V> m);
Set<K> keySet(); Collection<V> values();
COLLECTIONS JAVA
27
Les interfaces : Mappublic 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();
}}
COLLECTIONS JAVA
28
Les interfaces– 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.
COLLECTIONS JAVA
29
Les interfaces : Map – Les vues d’une tableIl 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();
COLLECTIONS JAVA
30
Les interfaces– Interfaces SortedSet, SortedMapMettent en évidence l’objet de comparaison utilisé pour trier les éléments.
COLLECTIONS JAVA
31
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.
Interfaces
32
public interface Iterator<E>{//renvoie true si l’objet de l’itération possède
encore au moins un élémentpublic boolean hasNext();public E next();public void remove();
}
Les interfaces : Iterator
33
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
34
La méthode next : Progression d’un itérateur
itérateurÉlément renvoyé
Les interfaces : Iterator
35
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
36
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
37
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
38
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 : Iterator
39
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 : Iterator
40
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.
Les interfaces : Iterator
41
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
Les interfaces : Iterator
42
Boucle « for each »– 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) { String nom = e.getNom();}
Les interfaces : Iterator
43
Classes abstraites et concrètes
44
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>.
COLLECTIONS JAVA
45
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.
COLLECTIONS JAVA
46
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.
COLLECTIONS JAVA
47
Les classes abstraitesExemple : 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 + " ] " ;
COLLECTIONS JAVA
48
Les classes concrètes– 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.
COLLECTIONS JAVA
49
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
50
Méthode qui peut renvoyer unejava.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
Méthode Optionnelle
51
Classes des collections
52
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
53
Les classes concrètes
AbstractCollection<E>
AbstractList<E>
AbstractSequentialList<E>
ArrayList<E>
LinkedList<E>
Collection<E>
List<E>
Deque<E>
COLLECTIONS JAVA
54
Les classes concrètes
AbstractCollection<E>
AbstractQueue<E> PriorityQueue<E>
ArrayQueue<E>
Collection<E>
Queue<E>
Deque<E>
COLLECTIONS JAVA
55
Les classes concrètes
AbstractCollection<E>
AbstractSet<E>
HashSet<E>
TreeSet<E>
Collection<E>
Set<E>
COLLECTIONS JAVA
56
Les classes concrètes
AbstractMap<K,V>
HashMap<K,V>
TreeMap<K,V>Map<K,V>
COLLECTIONS JAVA
57
Les classes concrètes–La bibliothèque a intégré au cadre
des collections des classes de conteneur plus anciennes.
AbstractList<E>
Stack<E>
Vector<E>
Properties
Hashtable<K,V>
Dictionary<K,V>
COLLECTIONS JAVA
58
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.
COLLECTIONS JAVA
59
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.
COLLECTIONS JAVA
60
Les classes abstraites implantant l’interface List<E> :– AbstractList<E>– AbstractSequentialList<E>
COLLECTIONS JAVA
61
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.
COLLECTIONS JAVA
62
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.
COLLECTIONS JAVA
63
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.
COLLECTIONS JAVA
64
Les classes concrètes dérivées:–ArrayList<E>–LinkedList<E>
COLLECTIONS JAVA
65
La classe ArrayList<E>–Classe dérivée de la classe AbstractList<E>
–utilise un tableau dynamique relogeable.
COLLECTIONS JAVA
66
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.
67
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);}
68
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
69
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
70
private int frequence (Object o){
int compteur=0; Iterator<E> it=iterator(); while (it.hasNext()) if (o.equals(it.next())) compteur++; return compteur;}
}
}
APPLICATION
71
Implantation de l’interface LIST
La classe LinkedList<E>– Classe dérivée de la classe AbstractSequentialList<E>
– utilise une liste chaînée.
72
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.
Implantation de l’interface LIST
73
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(); }
Implantation de l’interface LIST
74
La classe LinkedList<E>1 –
if (it2.hasNext()){ l1.addAll(l2); l2.clear(); }}
Implantation de l’interface LIST
75
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.next(); it.remove(); } } }
}
Implantation de l’interface LIST
76
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
Implantation de l’interface QUEUE
77
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é.
Implantation de l’interface QUEUE
78
L’interface Deque<E> est implémentée par deux classes concrètes:– ArrayDeque<E>– Linkedlist<E>
}
Implantation de l’interface DEQUE
79
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.
Implantation de l’interface DEQUE
80
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.
Implantation de l’interface DEQUE
81
La classe abstraite AbstractSet<E> implante partiellement l’interface Set<E>.
Il existe deux classes concrètes:–HashSet<E> et–TreeSet<E>.
Implantation de l’interface SET
82
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.
Implantation de l’interface SET
83
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.
Implantation de l’interface SET
84
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
Implantation de l’interface SET
85
La classe TreeSet<E>
public class TreeSet<E> extends AbstractSet<E> implements SortedSet<E> {
…//constructeur particulier : <? super E> limite aux supertypes
de Epublic 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);…
}
Implantation de l’interface SET
86
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
87
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).
Implantation de l’interface SET
88
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
89
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.
Implantation de l’interface SET
90
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
91
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
92
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
93
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 SET
94
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
95
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
96
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.
Implantation de l’interface MAP
97
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.
Implantation de l’interface MAP
98
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());}
Map : exemple
99
La classe TreeMap
import java.util.*;
public class AgenceBancaireBis { private Map<Integer,CompteBancaire> lesComptes;
public AgenceBancaireBis() { lesComptes =
new TreeMap<Integer,CompteBancaire>();
}
Map : exemple Compte
100
public void ajouterCompte(CompteBancaire c){ lesComptes.put(c.getNumero(), c);} //rechercher un compte à partir du numeropublic 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
101
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é");}
Map : exemple Compte
102
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
103
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
104
List<Integer> l =
new ArrayList<Integer>();
l.add(10);
l.add(-678);
l.add(87);
l.add(7);
int i = l.get(0);
Collections et types primitifs