Description

Les tableaux associatifs, ou tables d'association, (souvent appelés tables de hachage ou hachages par abus de langage, ou encore dictionnaires en Python) sont des collections de couples (clé, valeur).
En Java, les clés et les valeurs sont typées (les clés et les valeurs pouvant être de même type ou de types différents). Par abus de langage (encore !), on pourra dire qu'un tableau associatif est non typé quand les clés et les valeurs sont de type Object.

API : la classe HashMap

Il existe plusieurs implémentations qui mettent en œuvre des tableaux associatifs. Nous décrivons ci-dessous la classe HashMap de l'API (paquet : java.util).
Vous pourrez également regarder la classe Properties, qui étend HashMap. Cette classe est destinée à stocker des couples de type (String, String) et elle est dotée de méthodes pour sauvegarder l'ensemble de ces couples dans un fichier, ou restaurer les valeurs de ces couples par lecture d'un fichier (on s'en sert notamment pour lire/écrire des fichiers de configuration).

Import du paquet correspondant

      import java.util.HashMap;

      import java.util.*;

Construction

      HashMap<Object, Object> hMap = new HashMap<Object, Object>();
      HashMap<String, Object> hMap2 = new HashMap<String, Object>();
      HashMap<Token, Integer> hMap3 = new HashMap<Token, Integer>();
    

      HashMap hMap = new HashMap();

      HashMap<Object, Object> hMap = new HashMap<Object, Object>();

Utilisation : ajout/consultation de données

• Pour ajouter un couple clé-valeur : put()
  

        Integer nb = new Integer (18);
        String maChaine = "bonjour";
        Token tok1 = new Token ();
  
        hMap.put (tok1, nb);
        hMap.put (maChaine, tok1);
        hMap2.put (maChaine, tok1);
        hMap3.put (tok1, nb);
  	

• Pour récupérer la valeur d'une clé : get().
  Attention au type de l'objet retourné en fonction de la déclaration du tableau associatif :
  

        String str = hMap2.get (tok1);
        Integer cpt = hMap3.get (tok1);
        // on sait (parce qu'on l'a déclaré) que les valeurs de hMap2 sont de type String
        // et celles de hMap3 de type Integer
        // mais :
  
        Object obj = hMap.get (nb);
        if (obj instanceof Token)
            do sth;
  
        // ou, si l'on est sûr que l'objet associé à nb est de type Token :
        Token t = (Token) hMap.get (nb); // transtypage
  	

• Attention également à tester, le cas échéant, la nullité d'un objet retourné :

        HashMap<String, Integer> freqWord = new HashMap<String, Integer>();
  
        // ...
  
        Integer freq = freqTokenMap.get ("bonjour");
        if (freq == null)
            freq = new Integer (1);
        else
            freq = new Integer (freq.intValue() + 1);
  
        freqWord.put (tok, freq);
  	

Utilisation : parcours

• Pour accéder à l'ensemble des clés d'un tableau associatif : la méthode keySet(). Elle renvoie un ensemble (cf. l'interface Set de l'API) d'objets, sur lequel on peut invoquer les méthodes boolean contains(Object), int size(), boolean isEmpty(), mais surtout Iterator<E> iterator(). Une fois que l'on récupère un itérateur, on peut parcourir l'ensemble des clés du tableau associatif.
• On peut également accéder à la collection des valeurs du tableau associatif via la méthode values() qui renvoie une instance de classe qui implémente l'interface Collection, i.e. un objet qui se comporte comme un ArrayList (donc sur lequel on peut invoquer la méthode iterator() pour obtenir un itérateur).
• La plupart du temps, on parcourt la liste de clés et pour chacune d'entre elles, on récupère l'objet correspondant :

        Iterator itWords = freqWord.keySet().iterator();
  		
        while (itWords.hasNext())
        {
            String  currentWord = itWords.next(); 
  	  Integer currentFreq = freqWord.get(currentWord);
  	  System.out.println("Mot: " + currentWord + " -> Fréq = " + String.valueOf(currentFreq));
        }
  	

Autres implémentations

La classe TreeSet a les mêmes fonctionnalités que la classe HashMap. Elle est plus « efficace » en termes de temps d'accès aux valeurs car celles-ci sont rangées (sous forme d'arbre) dans un ordre particulier, selon la valeur des clés. Cela implique que le type des clés implémente l'interface Comparator<T>, (du paquet java.util). C'est le cas par exemple des types primitifs ou de certaines classes de l'API. Vous pouvez donc utiliser un TreeSet à la place d'une HashMap si vos clés sont de type Strint, int, ou n'importe quelle classe qui implémente cette interface.

[ Mention légale ]