Les collections

La conception d'une bonne architecture modulaire est loin d'être évidente. La notion de structure de données permet souvent de construire des modules de base d'une telle architecture. Quelques unes des structures de données les plus utiles sont rassemblées dans un ensemble cohérent de types figurant dans le paquet java.util, autour du concept de collection. Une collection représente un groupe d'objets, qui sont ses éléments. De façon précise, les éléments d'une collection ne sont pas des données, mais des références à des objets (instances de classe ou tableaux).

Les principales opérations sur une collection sont :

• ajouter un objet (add(Object o)) ;
• tester l'appartenance d'un objet (contains(Object o)) ;
• retirer un élément (remove(Object o)) ou tous les éléments (clear()) ;
• retirer tous les éléments (clear()) ;
• obtenir le nombre d'éléments (size()) ;
• tester si la collection ne contient aucun élément (isEmpty()).

Comme les éléments d'une collection ne peuvent pas être des valeurs d'un type primitif (char, int, double, etc.), il faut recourir à un constructeur d'une classe enveloppante (Character, Integer, Double, etc.) pour en faire des instances de classe : par exemple, si c est une collection, on ne pourra pas écrire c.add(2), mais c.add(new Integer(2)).

Certaines collections acceptent des éléments dupliqués, certaines sont ordonnées. Le paquet java.util  se compose d'interfaces et de classes ; l'interface Collection, qui spécifie toutes les collections, a plusieurs sous-interfaces spécialisées :

•     List spécifie les suites, c'est-à-dire les collections ordonnées ; la méthode int indexOf(Object o) retourne l'indice de la première occurrence de o dans la suite ; la méthode List subList(int initial, int final) retourne une référence vers la sous-liste formée des éléments d'indices $\ge$ initial et < final ; la méthode Object set(int i, Object o) remplace l'élément d'indice i par l'objet o ; la méthode Object get(int index) retourne l'élément d'indice i ;
•     Set spécifie les ensembles, c'est-à-dire les collections dont les éléments ne sont pas dupliqués ;
  •     SortedSet, sous-interface de Set spécifie les ensembles ordonnés (par ordre croissant) par une relation d'ordre sur ses éléments ; la méthode SortedSet subSet(Object initial, Object final) retourne une référence vers le sous-ensemble formé des éléments $\ge$ initial et < final ; first() et last() retournent respectivement le plus petit et le plus grand élément de l'ensemble ordonné.

Les collections disposent d'opérations ensemblistes extrêmement utiles permettant de tester l'appartenance de, d'ajouter ou de retirer tous les éléments d'une collection à une autre collection. Ce sont les méthodes :

• boolean containsAll(Collection c), pour l'inclusion ;
• boolean addAll(Collection c), pour la réunion ;
• boolean removeAll(Collection c), pour la différence ;
• boolean retainAll(Collection c), pour l'intersection.

Les trois dernières retournent true si l'opération a modifié la collection.

Les collections sont naturellement des structures de données hétérogènes, c'est-à dire que leurs éléments ne sont pas nécessairement du même type. On peut ainsi ajouter les éléments suivants à une liste l :

   l.add(new Integer(2));
   l.add("Java");
   l.add(java.awt.Color.red);

    D'autre part, les collections comprennent une autre interface, Map (qui n'est pas une sous-interface de Collection) :

• Map spécifie les tables, c'est-à-dire les collections associant une valeur à une clé, les clés ne pouvant être dupliquées, au plus une valeur étant associée à chaque clé ; la méthode put(Object clé, Object valeur) insère une association clé $\to$ valeur dans la table et retourne l'objet précédemment associé à cette clé ou bien null ; get (Object clé) retourne l'objet associé à clé par cette table, ou bien null ;
  • SortedMap, sous-interface de Map spécifie les tables dont l'ensemble des clés est ordonné ; la méthode subMap(Object initial, Object final) retourne une référence vers la sous-table formé des associations de clé $\ge$ initial et < final ; firstKey() et lastKey() retournent respectivement la plus petite et le plus grande clé de la table ordonnée.