www.infkoffler.com - Site de cours d'informatique

Accueil

Java Standard Edition

Java EE 5

Visual Basic .Net 2005

Cours Javascript - DOM - DHTML

Nouveautés sur le site

Contacts

Accueil > Java Standard Edition > Les collections(6): L'interface Map(java.util)

____________________________________________________________________________________________________

Connexion

Les collections(6): L'interface Map (java.util)

Sommaire :

I) Généralités
II) L'interface Map (java.util)
  II-1) Les membres de Map
    II-1-A) Les méthodes de Map
    II-1-B) L'interface Map.Entry

I) Généralités

Dans le chapitre sur le framework des collections, nous avons appris que Map est une des six interfaces du framework de collections.

En résumé,

Map est un ensemble de paires clé/valeur. Chaque clé est unique, et ne peut mapper au plus qu'une valeur.
Certaines implémentations ont des restrictions sur les clés et les valeurs autorisées. Par exemple Hashtable, qui n'autorise pas de null pour les clés et valeurs; par contre HashMap n'impose pas de contraintes.
Trois méthodes permettent d'avoir trois vues de collection. Une permet d'obtenir une collection des valeurs.
La deuxième permet d'avoir un Set des clés. Enfin la troisième nous donne un Set des entrées, une entrée étant un objet représentant une paire clé/valeur.

II) L'interface Map (java.util)

C'est une interface générique, à deux paramètres de généricité.

II-1) Les membres de Map

II-1-A) Les méthodes de Map

hormis les trois méthodes donnant trois vues de la map, les autres méthodes sont classiques pour une telle collection de mapping clé/valeur.
Retourne le nombre de mapping clé-valeur de la map. A noter que si la map contient plus de Integer.MAX_VALUE éléments, elle retourne Integer.MAX_VALUE.
Retourne true si la map n'a aucune paire clé/valeur.
Retourne vrai si la map contient la clé. C'est à dire si la map contient un mapping pour une clé k, tel que key.equals(k) est vrai. Ou alors si key est null, si la map contient un mapping avec une clé k qui est null. On remarque que null pour une clé (quand cela est permis par la map), est considéré comme une valeur ordinaire, et donc doit être unique, comme toute clé.
Retourne vrai si la map contient au moins une valeur value. C'est à dire si la map contient au moins une valeur v, telle que value.equals(v).
Ou alors si value est null, si la map contient au moins une valeur null
Retourne la valeur mappée à la clé, ou null si la map ne contient pas de valeur mappée à cette clé. Si key est null, recherche l'entrée dont la clé vaut null.
Si la map permet les valeurs null, alors un résultat null de get, ne permet pas de savoir si la clé est présente ou non. Dans ce cas, un appel à containsKey auparavant, permet de résoudre le problème. En effet, par exemple si 5 est mappé à la valeur null, containsKey donnera true pour la clé 5, on pourra être certain alors que le résultat du get signifie que la valeur associée est null.
Par contre, pour une clé 4 inexistante, containsKey retournera false, on ne réalisera pas alors de get.
Opération optionnelle (UnsupportedOperationException sinon). Associe la valeur à la clé spécifiée. Si la clé est déjà présente, alors l'ancienne valeur est remplacée par la nouvelle.
Opération optionnelle (UnsupportedOperationException sinon). Supprime le mapping pour la clé spécifiée, si la clé est présente.
Opération optionnelle (UnsupportedOperationException sinon). Permet de copier tous les mappings de la map en paramètre, vers la notre. C'est comme si on avait effectué un put(k, v), pour tous les mappings de la map en argument.
Le comportement est indéfini si la map à copier est modifiée en cours de progression.
Opération optionnelle (UnsupportedOperationException sinon). Permet de supprimer tous les mappings de notre map, qui sera vide à la fin.
keySet permet d'obtenir une vue de collection de notre map, vue qui est ici un Set de clés. En effet, comme les clés sont uniques, elles peuvent former un Set, qui, par définition, et un ensemble d'éléments uniques. On obtient une collection qui ne s'intéresse qu'aux clés( on obtient un jeu de clés!), et qui ne contient pas les valeurs de la map.
values permet d'obtenir une collection contenant toutes les valeurs. C'est une vue de collection de la map.
Permet d'obtenir une vue de collection de notre map, vue qui est ici un Set d'entrées(Map.Entry). En effet, chaque entrée est unique, puisque chaque clé est unique. On peut donc réaliser un Set d'Entry, car on n'aura jamais deux Entry ayant la même clé et la même valeur. Cette méthode entrySet permet d'obtenir un tel Set.
Compare l'égalité de l'objet en paramètre, avec notre map. Pour cela, il faut que l'objet o soit une map, et que les deux maps aient les mêmes mappings. Une façon de l'écrire formellement est:
m1.entrySet().equals(m2.entrySet()) . Les deux jeux d'entrées sont égaux dans ce cas.
Retourne la valeur hashcode pour notre map.

Revoyons ce que nous avions dit sur le hashcode, dans le cours sur la classe String. Il me semble intéressant de redéfinir le hashcode ici, car ce principe est utilisé dans des maps comme HashMap ou Hashtable.
Je profite donc de la méthode hashcode() de l'interface Map, pour parler du hashcode.

Le hash code est une valeur entière, qui permet de nous aider à tester rapidement que deux objets(d'une même classe) sont égaux. Deux objets sont égaux, si leurs méthodes hashCode retourne le même entier, et ensuite on doit appeler leur méthode equals. Deux objets peuvent avoir le même hashcode, et les deux objets ne pas être égaux. Mais deux objets ne peuvent pas être égaux, si leur hashcode est différent.
Cela permet de comparer des objets plus rapidement. La classe doit implémenter une méthode int hashCode(), qui soit la plus appropriée possible, un compromis entre la rapidité de réponse, et la capacité à être précise du point de vue égalité. Par exemple, pour deux objets Personne, on peut imaginer une méthode hashCode qui sera une fonction des deux dates de naissance, et de la première lettre du nom de famille( c'est un exemple!).
Le hashcode est utilisé notamment dans des classes comme HashTable (java.util), pour comparer les clés. Dans ces classes, il est à noter que pour toutes les clés de la hash table, le hashcode est calculé une fois pour toutes à l'insertion de la paire clé/valeur. Ce qui signifie qu'à chaque recherche de clé, il n'y a que le hashcode de la clé à rechercher, qui est à calculer.
Il ne nous reste plus ensuite qu'à le comparer avec les hash codes déjà calculés.
La performance de la méthode hashCode() est donc moins importante ici; et sa précision présente plus d'intérêt ( c'est à dire diminuer le nombre d'objets ayant le même hashcode), afin de diminuer les appels à equals pour les objets ayant le même hash code.
Note: en réalité, l'implémentation des hash tables est un peu plus complexe que cela. Car on profite du hash code pour en déduire(avec une valeur absolue, puis un modulo de la taille du tableau) un index dans un tableau de listes chaînées, qui sont chacune une liste chaînée de paires clé/valeur possibles(ça limite la recherche, mais toutes n'ont pas forcément le même hash code). Mais le principe reste tout-à-fait celui qu'on a énoncé.

II-1-B) L'interface Map.Entry

C'est une public static interface, qui est déclarée à l'intérieur de l'interface Map. Il y a juste "interface", mais, sous-entendu, elle est public, et static.
On y accède donc par Map.Entry

En résumé, on dit qu'une entrée (Entry) représente une paire clé/valeur. Elles sont utilisées par la méthode Map.entrySet, qui retourne un Set de Entry. On précise aussi que les Entry obtenues par l'itérator ne sont pas mises à jour automatiquement suivant les modifications qu'on ferait à la map après.

Regardons les méthodes:
Retourne la clé correspondante à l'entrée. Une IllegalStateException peut, mais ce n'est pas obligé, être déclenchée si l'entrée a été supprimée de la map sous-jacente.
Retourne la valeur correspondante à l'entrée. Une IllegalStateException peut, mais ce n'est pas obligé, être déclenchée si l'entrée a été supprimée de la map sous-jacente.
Opération optionnelle (UnsupportedOperationException sinon). permet de remplacer la valeur de notre entrée, par une autre valeur. La map sous-jacente est affectée en conséquence. Le comportement est indéfini si l'entrée a été supprimée de la map( par le remove de l'itérateur du Set retourné par entrySet).
Une IllegalStateException peut, mais ce n'est pas obligé, être déclenchée si l'entrée a été supprimée de la map sous-jacente.
Retourne vrai si l'Object o est aussi une map entry, et si c'est la même entrée, c'est à dire la même clé et la même valeur.
L'opérateur ^ est le XOR logique(bit à bit).

Exemple d'implémentation de hashCode() d'une map entry:
La méthode hashCode() d'une map entry n'est, à ma connaissance, pas utilisée pour les recherches d'entrées dans les hash maps(par exemple, elle n'est pas utilisée dans HashMap). C'est compréhensible, car on a besoin, à partir d'une clé, de savoir si l'entrée est présente, et non à partir d'une entrée.

RETOUR HAUT