Introduction

Il s'agit d'un procédé général permettant de regrouper sous forme d'un objet unique différents éléments (par exemple un ensemble de données constituant un répertoire).
Les premières versions de Java proposaient différentes implantations des collections : tableaux, vecteurs (Vector), ou table de hâchage (Hashtable)

On trouve dorénavant dans Java une architecture unifiée pour représenter et manipuler des collections («collection framework»).
Ces différents cadres disponibles pour la manipulation des collections offrent :

• une interface : des types de données abstraits permettent la manipulation des collections indépendamment de leurs représentations ;
• des implantations concrètes des interfaces précédentes ;
• des algorithmes sous forme de méthodes réalisations des opérations utiles.

L'interface Collection

Elle constitue la racine de la hiéararchie des collections dont la figure suivante donne un aperçu :

Cette interface est utilisée pour transmettre des collections et les manipuler avec le maximum de généralités. Des sous-interfaces particulières sont fournies par ailleurs (par exemple Set, SortedSet ou List).

Bien que JAVA ne permette pas de spécifier dans une interface des constructeurs, toute implantation de cette interface devrait contenir un constructeur sans paramètre créant une collection vide et un constructeur avec un argument construisant une collection contenant les mêmes éléments que son argument.

Les méthodes de l'interface

• boolean add(Object o)
• boolean addAll(Collection c)
• void clear()
• boolean contains(Object o)
• boolean containsAll(Collection c)
• boolean equals(Object o)
• int hashCode()
• boolean isEmpty()
• Iterator iterator()
• boolean remove(Object o)
• boolean removeAll(Collection c)
• boolean retainAll(Collection c)
• int size()
• Object[] toArray()
• Object[] toArray(Object[] t)

La classe abstraite AbstractCollection

Cette classe définie sous la forme :
    public abstract class AbstractCollection
                 extends Object implements Collection
fournit un squelette d'implantation de l'interface Collection

Les interfaces Set et SortedSet

Ces deux interfaces définies sous la forme 
    public interface Set extends Collection
    public interface SortedSet extends Set
correspondent toutes les deux à des collections sans duplication d'éléments.

La classe abstraite AbstractSet

Cette classe fournit un squelette d'implantation de l'interface Set.
Elle est définie sous la forme :
    public abstract class AbstractSet
                 extends AbstractCollection implements Set

Quelques classes concrètes

Quelques classes concrètes étendant la classe AbstractSet sont :

• public class TreeSet extends AbstractSet
    implements SortedSet, Cloneable, Serializable ;
• public class HashSet extends AbstractSet
    implements Set, Cloneable, Serializable ;

L'interface List

Définie sous la forme
    public interface List extends Collection
elle correspond à une collection ordonnée permettant en particulier l'insertion en un point particulier. La duplication d'éléments y est par ailleurs possible.

Méthodes ajoutéees dans l'interface

• void add(int index, Object element)
• boolean addAll(int index, Collection c)
• int indexOf(Object o)
• int lastIndexOf(Object o)
• ListIterator listIterator()
• ListIterator listIterator(int index)
• Object remove(int index)
• Object set(int index, Object element)
• List subList(int fromIndex, int toIndex)

La classe abstraite AbstractList

Elle fournit un squelette d'implantation de l'interface List

Quelques classes concrètes étendant AbstractList

• public class Vector extends AbstractList
    implements List, RandomAccess, Cloneable, Serializable
• public class ArrayList extends AbstractList
    implements List, RandomAccess, Cloneable, Serializable
• public class LinkedList extends AbstractSequentialList
    implements List, Cloneable, Serializable