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.


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.


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.


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.


34

La méthode next : Progression d’un itérateur

itérateurÉlément renvoyé


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

}


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();

…}


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


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.


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


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.


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


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();}


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



AbstractQueue<E> PriorityQueue<E>

ArrayQueue<E>

Collection<E>

Queue<E>

Deque<E>

COLLECTIONS JAVA

55



AbstractSet<E>

HashSet<E>

TreeSet<E>

Collection<E>

Set<E>

COLLECTIONS JAVA

56


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.


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(); }


74

La classe LinkedList<E>1 –

if (it2.hasNext()){ l1.addAll(l2); l2.clear(); }}


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(); } } }

}


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.


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.


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.


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.


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


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);…

}


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>.


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).


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);


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.


90

La classe TreeSet<E>import java.util.*;

public class AgenceBancaire { private Set<CompteBancaire> lesComptes;

public AgenceBancaire () { lesComptes = new TreeSet<CompteBancaire>();

}


91

public boolean ajouterCompte(CompteBancaire c) {return lesComptes.add(c);

}public void supprimerCompte(CompteBancaire c) lesComptes.remove(c);

}public String toString() {return lesComptes.toString();

}


92

public void traitementQuotidien(){ Iterator<CompteBancaire> it = lesComptes.iterator();

while (it.hasNext()){CompteBancaire c= it.next();

c.traitementQuotidien(); } System.out.println("Traitement Quotidien effectué");

}


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


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.


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.


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.


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();}


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é");}


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));



int i = l.get(0).intValue();


104

List<Integer> l =

new ArrayList<Integer>();

l.add(10);

l.add(-678);

l.add(87);

l.add(7);

int i = l.get(0);


1 COURS DE PROGRAMMATION ORIENTEE OBJET : Les collections en Java.

Documents

Transcript of 1 COURS DE PROGRAMMATION ORIENTEE OBJET : Les collections en Java.