put(key, value), qui permet d'associer un objet à une clé ;
get(key), qui retourne la valeur qui a été associée à cette clé, ou
null s'il n'y en a pas.
remove(key), qui supprime la clé de cette table, et la valeur qui lui est associée.
Set.
Collection.
put(K key, V value) et
get(K key) : ces deux méthodes permettent d'associer une clé à une valeur, et de récupérer cette valeur à partir de cette clé, respectivement.
remove(K key) : permet de supprimer la clé passée en paramètre de cette table, et la valeur associée.
keySet() : retourne l'ensemble de toutes les clés de cette table de hachage. Cet ensemble ne peut pas contenir de doublons, il s'agit d'un
Set<K>, donc les éléments sont de type
K. Cet ensemble est une vue sur les clés de la table de hachage. Donc les éléments ajoutés à cette table seront vus dans ce
Set. Il supporte les méthodes
remove() et
removeAll(), mais pas les méthodes d'ajout d'éléments. Retirer une clé de cet ensemble retire également la valeur qui lui est associée.
values() : retourne l'ensemble de toutes les valeurs stockées dans cette table de hachage. À la différence de l'ensemble des clés, l'ensemble des valeurs peut contenir des doublons. Il est donc de type
Collection<V>. Cette collection est également une vue sur la table : toute valeur ajoutée à la table sera vue dans cette collection. Elle supporte les méthode
remove() et
removeAll(), qui ont pour effet de retirer également la clé associée à cette valeur, mais pas les méthodes d'ajout.
entrySet() : retourne l'ensemble des entrées de cette table de hachage. Cet ensemble est un
Set, dont les éléments sont de type
Map.Entry. Nous allons voir l'interface
Map.Entry dans la suite de cette partie. Cet ensemble est lui aussi une vue sur la table, qui reflète donc les modifications qui peuvent y être faites. Il supporte les opérations de retrait d'éléments, mais pas les opérations d'ajout.
clear() : efface tout le contenu de la table.
size() et
isEmpty() : retourne le cardinal de la table, et un booléen qui indique si cette table est vide ou pas.
putAll(Map map) : permet d'ajouter toutes les clés de la table passée en paramètre à la table courante.
containsKey(K key) et
containsValue(V value) : permettent de tester si la clé ou la valeur passée en paramètre sont présentes dans cette table.
getKey() et
getValue(), qui retournent bien sûr la clé et la valeur de ce couple.
La seule façon d'obtenir un objet de type
Map.Entry est de faire un appel à la méthode
Map.entrySet(), et d'itérer sur le
Set obtenu en retour.
Cet objet est une vue sur la table. Il possède également une méthode
setValue(V value), qui permet de modifier la valeur associée à une clé durant une itération.
SortedMap permet de stocker des tables de hachage triées dans l'ordre de ses clés. De la même façon que pour
SortedSet, cet ordre peut être défini de deux façons, soit par le fait que les clés de cette table sont des objets
Comparable, soit en donnant un objet
Comparator à la construction de la table. Rappelons que les classes enveloppe des types primitifs, et la classe
String sont toutes des classes
Comparable.
On retrouve des méthodes conçues sur le même modèle que
SortedSet.
firstKey() et
lastKey() : retournent respectivement la plus petite clé et la plus grande.
headMap(K toKey) et
tailMap(K fromKey) : retournent des vues sur la table maître, contenant les premières clés jusqu'à
toKey, et les dernières clés à partir de
fromKey, respectivement.
subMap(K fromKey, K, toKey) : retourne une vue sur la table maître, de la clé
fromKey, à la clé
toKey.
SortedSet, le fait que la borne donnée lors de la construction de ces vues sur la table maître suit une logique obscure, qui impose de toute façon de consulter la documentation à chaque utilisation, ce qui a incité, en Java 6, à créer une interface supplémentaire :
NavigableMap.
NavigableMap est une extension de
SortedMap, qui complète le jeu de méthodes de sélection de vues sur la table maître.
ceilingKey(K key) et
floorKey(K key) : retournent respectivement la plus petite clé supérieure ou égale, et la plus grande inférieure ou égale à la clé passée en paramètre.
ceilingEntry(K key) et
floorEntry(K key) : retournent respectivement la plus petite clé supérieure ou égale, et la plus grande inférieure ou égale à la clé passée en paramètre.
higherKey(K key) et
lowerKey(K key) : retournent respectivement la plus petite clé strictement supérieure, et la plus grande strictement inférieure à la clé passée en paramètre.
higherEntry(K key) et
lowerEntry(K key) : retournent respectivement la plus petite clé strictement supérieure, et la plus grande strictement inférieure à la clé passée en paramètre.
firstEntry() et
lastEntry() : retournent respectivement la plus petite entrée de cette table, et la plus grande.
headMap(K sup, boolean inclusive) et
tailMap(K inf, boolean inclusive) : retournent des vues sur la table maître, dont les clés sont plus petites et plus grandes respectivement que la borne passée en paramètre. Le fait que l'inégalité soit stricte ou non est réglée par la valeur du boolean
inclusive.
subMap(K fromKey, K, toKey) et
subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) : retournent une vue sur la table maître, contenant les entrées dont les clés sont plus grandes que
fromKey et plus petites que
toKey. Le fait que les bornes soient ou non incluses dans la vue retournée est réglé par les deux booléens
fromInclusive et
toInclusive.
navigableKeySet() et
descendingKeySet() retournent deux vues sur les clés de la table maître, triés dans l'ordre de cette table et dans son ordre inverse respectivement. Les ensembles retournés sont de type
NavigableSet et supportent les opérations de suppression.
pollFirstEntry() et
pollLastEntry() : retirent de la table, et retournent l'entrée dont la clé est la plus petite, respectivement la plus grande, de cette table.
navigableKeySet() et
descendingKeySet() : retournent une vue sur l'ensemble des clés de cette table, dans l'ordre croissant et dans l'ordre décroissant respectivement. Cette vue supporte les opérations d'effacement, mais pas les opérations d'ajout.
descendingMap() : retourne une vue qui expose cette même table dans l'ordre inverse. Cela signifie que si l'on itère sur les éléments (clés ou entrées) de cette vue, cette itération se fera dans l'ordre décroissant des clés de la table maître.
Map :
Hashtable est présente depuis Java 1.0, et est synchronisée ;
HashMap autorise les valeurs nulles, et n'est pas synchronisée ;
LinkedHashMap étend
HashMap et entretient une liste chaînée permettant d'itérer sur les entrées dans un ordre fixe.
SortedMap ne possède qu'une unique implémentation :
TreeMap. Cette classe implémente également
NavigableMap, extension de
SortedMap. Si l'on doit utiliser
TreeMap comme classe d'implémentation, autant utiliser l'interface
NavigableMap, qui offre un jeu de méthodes beaucoup plus riche.
Enfin,
NavigableMap ne possède aussi que
TreeMap comme implémentation.
Exemple 13. Utilisation d'une table de type
HashMap
// dans une méthode main // création de quelques marins Marin m1 = new Marin("Surcouf", "Alain") ; Marin m2 = new Marin("Tabarly", "Eric") ; Marin m3 = new Marin("Auguin", "Christophe") ; Marin m4 = new Marin("Surcouf", "Robert") ; // création d'une table dont les clés sont des String // et les valeurs des marins Map<String, Marin> map = new HashMap<String, Marin>() ; // ajout de nos marins à cette table // remarquons que deux ajouts possèdent la même clé map.put(m1.getNom(), m1) ; map.put(m2.getNom(), m2) ; map.put(m3.getNom(), m3) ; map.put(m4.getNom(), m4) ; // première interrogation de la table System.out.println("[Surcouf] -> " + map.get("Surcouf")) ; System.out.println("Eléments : " + map.size()) ; // parcours de la table par ses entrées for (Map.Entry<String, Marin> entry : map.entrySet()) { System.out.println("[" + entry.getKey() + "] -> " + entry.getValue()) ; }
[Surcouf] -> Surcouf Robert Eléments : 3 [Tabarly] -> Tabarly Eric [Surcouf] -> Surcouf Robert [Auguin] -> Auguin ChristopheAlors que l'on a ajouté quatre marins dans notre table, seulement trois se retrouvent effectivement dedans. Cela est dû au fait que deux de ces marins ont même
nom, et sont donc associés à la même clé. Le deuxième ajout écrase donc le premier.
Prenons à présent le même exemple, avec une
SortedMap. Nos clés sont des
String. Cette classe est
Comparable, nous n'avons donc pas besoin de fournir de
Comparator à notre table triée.
Exemple 14. Utilisation d'une table de type
TreeMap
Marin m1 = new Marin("Surcouf", "Robert") ; Marin m2 = new Marin("Tabarly", "Eric") ; Marin m3 = new Marin("Auguin", "Christophe") ; NavigableMap<String, Marin> map = new TreeMap<String, Marin>() ; map.put(m1.getNom(), m1) ; map.put(m2.getNom(), m2) ; map.put(m3.getNom(), m3) ; System.out.println("Eléments : " + map.size()) ; for (Map.Entry<String, Marin> entry : map.entrySet()) { System.out.println("[" + entry.getKey() + "] -> " + entry.getValue()) ; } // construction d'une vue en ordre inverse System.out.println("Inversion...") ; NavigableMap<String, Marin> reversedMap = map.descendingMap() ; for (Map.Entry<String, Marin> entry : reversedMap.entrySet()) { System.out.println("[" + entry.getKey() + "] -> " + entry.getValue()) ; } // suppression de Tabarly de la table maître // observons ce qui se passe pour la vue System.out.println("Suppression de Tabarly...") ; map.remove("Tabarly") ; for (Map.Entry<String, Marin> entry : reversedMap.entrySet()) { System.out.println("[" + entry.getKey() + "] -> " + entry.getValue()) ; }
Eléments : 3 [Auguin] -> Auguin Christophe [Surcouf] -> Surcouf Robert [Tabarly] -> Tabarly Eric Inversion... [Tabarly] -> Tabarly Eric [Surcouf] -> Surcouf Robert [Auguin] -> Auguin Christophe Suppression de Tabarly... [Surcouf] -> Surcouf Robert [Auguin] -> Auguin ChristopheOn constate bien que notre table s'est triée automatiquement par ordre croissant de clé. De plus, la vue décroissante que l'on a créée dessus a bien pris en compte l'effacement de Tabarly.