La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

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

Présentations similaires


Présentation au sujet: "1 COURS DE PROGRAMMATION ORIENTEE OBJET : Les collections en Java."— Transcription de la présentation:

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

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

3 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 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 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 6  Avec le JDK 5.0, les classes et les interfaces sont devenues génériques avec paramètre de type : List –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 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 8 List l = new ArrayList (); 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 9 Map frequences = new HashMap (); 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 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 11  Les interfaces SortedSet Collection SetListQueue Deque COLLECTIONS JAVA

12 12  Les interfaces SortedMap Map ListIterator Iterator COLLECTIONS JAVA

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

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

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

16 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 17  Les interfaces : List interface List extends Collection –Les méthodes supplémentaires void add (int index, E element); E get (int index); int indexOf (Object object); ListIterator listIterator (); E remove (int index); E set (int index, E element); List subList (int start, int stop); COLLECTIONS JAVA

18 18  Les interfaces –Interface Set public interface Set extends Collection 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 19  Les interfaces : Queue public interface Queue extends Collection 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 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 exceptionReturns special value insertionboolean add(E e)boolean offer(E e) extractionE remove()E poll() consultationE element()E peek() COLLECTIONS JAVA

21 21  Les interfaces : Interface Deque (double ended queue) public interface Deque extends Queue 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 22  Les interfaces : Deque Throws exceptionReturns special value insertionboolean addFirst(E e)boolean offerFirst (E e) extractionE removeFirst ()E pollFirst () consultationE getFirst ()E peekFirst () Throws exceptionReturns special value insertionboolean addLast(E e)boolean offerLast (E e) extractionE removeLast ()E pollLast () consultationE getLast ()E peekLast () COLLECTIONS JAVA

23 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 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 25  Les interfaces : Map public interface Map { 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 26  Les interfaces : Map void clear(); V remove(Object key); void putAll(Map m); Set keySet(); Collection values(); COLLECTIONS JAVA

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

28 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 29  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 keySet(); L’ensemble des valeurs fournie par la méthode public Collection values(); L’ensemble des paires clé/valeur fournie par la méthode public Set > entrySet(); COLLECTIONS JAVA

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

31 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 possède une méthode public Iterator iterator() qui associe un itérateur à une collection ce qui permet de parcourir la collection. Interfaces

32 32 public interface Iterator { //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

33 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 34  La méthode next : Progression d’un itérateur itérateur Élément renvoyé Les interfaces : Iterator

35 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 it = conteneur.iterator(); while (it.hasNext()){ E element = it.next(); //utilisation de l’object element } Les interfaces : Iterator

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

37 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 it = conteneur.iterator(); it.next(); //passer l’élément it.remove(); //supprimer l’élement Les interfaces : Iterator

38 38  Implantation de l’interface Iterator 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 39  Les interfaces : ListIterator 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 40  Les interfaces : ListIterator 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 41  Interface Iterable –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 42  Boucle « for each » –Boucle « normale » : for(Iterator 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 43 Classes abstraites et concrètes

44 44  Les classes abstraites – AbstractCollection qui implémente Collection, – AbstractList qui implémente List, – AbstractSequentialList qui implémente List, – AbstractSet qui implémente Set, – AbstractQueue qui implémente Queue, – AbstractMap qui implémente Map. COLLECTIONS JAVA

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

48 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 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 50  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 Méthode Optionnelle

51 51 Classes des collections

52 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 53  Les classes concrètes AbstractCollection AbstractList AbstractSequentialList COLLECTIONS JAVA

54 54  Les classes concrètes AbstractCollection AbstractQueue COLLECTIONS JAVA

55 55  Les classes concrètes AbstractCollection AbstractSet COLLECTIONS JAVA

56 56  Les classes concrètes AbstractMap COLLECTIONS JAVA

57 57  Les classes concrètes –La bibliothèque a intégré au cadre des collections des classes de conteneur plus anciennes. AbstractList Stack Vector Properties Hashtable Dictionary COLLECTIONS JAVA

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

59 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 60  Les classes abstraites implantant l’interface List : – AbstractList – AbstractSequentialList COLLECTIONS JAVA

61 61  La classe AbstractList –C’est une implantation partielle de l’interface List. –Elle fournit l’ossature des implantations complètes de l’interface List 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 62  La classe AbstractList –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 63  La classe AbstractSequentialList –étend la classe AbstractList. –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 64  Les classes concrètes dérivées: – ArrayList – LinkedList COLLECTIONS JAVA

65 65  La classe ArrayList –Classe dérivée de la classe AbstractList –utilise un tableau dynamique relogeable. COLLECTIONS JAVA

66 66 APPLICATION  La classe ArrayList –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 67 APPLICATION public class SacGeneric extends AbtractCollection { private List sac; public SacGeneric(){ sac = new ArrayList (); } public boolean add(E e) { return sac.add(e); }

68 68 APPLICATION public Iterator 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 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 70 private int frequence (Object o){ int compteur=0; Iterator it=iterator(); while (it.hasNext()) if (o.equals(it.next())) compteur++; return compteur; } APPLICATION

71 71 Implantation de l’interface LIST  La classe LinkedList –Classe dérivée de la classe AbstractSequentialList –utilise une liste chaînée.

72 72  La classe LinkedList –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 73  La classe LinkedList 1 – public static void fusionner(LinkedList l1, LinkedList l2) { ListIterator it1 = l1.listIterator(); ListIterator it2 = l2.listIterator(); while (it1.hasNext() && it2.hasNext()){ it1.next(); it1.add(it2.next()); it2.remove(); } Implantation de l’interface LIST

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

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

76 76  La classe abstraite AbstractQueue implante partiellement l’interface Queue.  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 77  La classe PriorityQueue –Implémente l’interface Queue en utilisant un tas. –Les éléments doivent être des instances d’une classe qui implémente l’interface Comparable. –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 78  L’interface Deque est implémentée par deux classes concrètes: – ArrayDeque – Linkedlist } Implantation de l’interface DEQUE

79 79  La classe ArrayDeque –Classe dérivée de la classe AbstractCollection –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 80  La classe LinkedList –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 81  La classe abstraite AbstractSet implante partiellement l’interface Set.  Il existe deux classes concrètes: – HashSet et – TreeSet. Implantation de l’interface SET

82 82  La classe HashSet –Implante l’interface Set à 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 83  La classe HashSet –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 84  La classe TreeSet –Implémente l’interface SortedSet. – TreeSet 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 85  La classe TreeSet public class TreeSet extends AbstractSet implements SortedSet { … //constructeur particulier : limite aux supertypes de E public TreeSet(Comparator comparator); //méthodes requises par l’interface SortedSet public Comparator comparator(); public E first(); public E last(); public SortedSet subSet(E fromElement, E toElement); … } Implantation de l’interface SET

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

87 87  La classe TreeSet –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 comparator) en passant un objet Comparator en paramètre. Comparator est une interface qui possède une seule méthode public int compare( T o1, T o2). Implantation de l’interface SET

88 88  La classe TreeSet 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. –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 t = new TreeSet(comp); Implantation de l’interface SET

89 89  La classe TreeSet 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 90  La classe TreeSet import java.util.*; public class AgenceBancaire { private Set lesComptes; public AgenceBancaire () { lesComptes = new TreeSet (); } Implantation de l’interface SET

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

93 93 public CompteBancaire rechercherCompte(String nom,String type){ CompteBancaire c=null; Iterator 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 94  La classe abstraite AbstractMap implante partiellement l’interface Map.  Il existe deux classes concrètes principales: – HashMap – TreeMap  Deux autres classes concrètes: – WeakHashMap ( gère les clés qui ne sont plus utilisées). – LinkedHashMap (garde une trace de l’ordre d’insertion). Implantation de l’interface MAP

95 95  La classe HashMap Comme HashSet, HashMap implante l’interface Map à partir d’une table de hachage. Implantation de l’interface MAP

96 96  La classe TreeMap –Implémente l’interface SortedMap. – TreeMap 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 97  La classe TreeMap 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 98 Map hm = new HashMap (); 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 elements = hm.values(); for (Employe employe : employes) { System.out.println(employe.getNom()); } Map : exemple

99 99  La classe TreeMap import java.util.*; public class AgenceBancaireBis { private Map lesComptes; public AgenceBancaireBis() { lesComptes = new TreeMap (); } Map : exemple Compte

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

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

102 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 103 List l = new ArrayList (); 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 104 List l = new ArrayList (); l.add(10); l.add(-678); l.add(87); l.add(7); int i = l.get(0); Collections et types primitifs


Télécharger ppt "1 COURS DE PROGRAMMATION ORIENTEE OBJET : Les collections en Java."

Présentations similaires


Annonces Google