L'interface Collection définit les opérations courantes pour les listes, les vecteurs, les piles, les files d'attente, les files d'attente prioritaires et les ensembles.

Java Collections Framework prend en charge deux types de conteneurs :

• Celui qui stocke une collection d'éléments est simplement appelé une collection.
• L'autre, pour stocker les paires clé/valeur, est appelée une map.

Les cartes sont des structures de données efficaces pour rechercher rapidement un élément à l'aide d'une clé. Voici les collections suivantes.

• Les Setstockent un groupe d'éléments non dupliqués.
• Les Listesstockent une collection ordonnée d'éléments.
• Stackstocke les objets qui sont traités selon le principe du dernier entré, premier sorti.
• La file d'attentestocke les objets qui sont traités selon le principe du premier entré, premier sorti.
• PriorityQueuestockent les objets qui sont traités dans l'ordre de leurs priorités.

Les fonctionnalités communes de ces collections sont définies dans les interfaces et les implémentations sont fournies dans des classes concrètes, comme le montre la figure ci-dessous.

Toutes les interfaces et classes définies dans Java Collections Framework sont regroupées dans le package java.util.

La conception de Java Collections Framework est un excellent exemple d'utilisation d'interfaces, de classes abstraites et de classes concrètes. Les interfaces définissent le cadre. Les classes abstraites fournissent une implémentation partielle. Les classes concrètes implémentent les interfaces avec des structures de données concrètes. Fournir une classe abstraite qui implémente partiellement une interface permet à l'utilisateur d'écrire facilement le code. L'utilisateur peut simplement définir une classe concrète qui étend la classe abstraite plutôt qu'implémente toutes les méthodes de l'interface. Les classes abstraites telles que AbstractCollection sont fournies pour plus de commodité. Pour cette raison, elles sont appelées classes abstraites de commodité.

L'interface Collection est l'interface racine permettant de manipuler une collection d'objets. Ses méthodes publiques sont répertoriées dans la figure ci-dessous. La classe AbstractCollection fournit une implémentation partielle de l'interface Collection. Il implémente toutes les méthodes de Collection à l'exception des méthodes add, size et iterator. Ceux-ci sont implémentés dans des sous-classes concrètes appropriées.

L'interface Collection fournit les opérations de base pour ajouter et supprimer des éléments dans une collection. La méthode add ajoute un élément à la collection. La méthode addAll ajoute tous les éléments de la collection spécifiée à cette collection. La méthode remove supprime un élément de la collection. La méthode removeAll supprime les éléments de cette collection qui sont présents dans la collection spécifiée. La méthode retainAll conserve les éléments de cette collection qui sont également présents dans la collection spécifiée. Toutes ces méthodes renvoient boolean. La valeur de retour est true si la collection est modifiée à la suite de l'exécution de la méthode. La méthode clear() supprime simplement tous les éléments de la collection.

Les méthodes addAll, removeAll et retainAll sont similaires aux opérations d'union, de différence et d'intersection d'ensemble.

L'interface Collection propose diverses opérations de requête. La méthode size renvoie le nombre d'éléments dans la collection. La méthode contains vérifie si la collection contient l'élément spécifié. La méthode containsAll vérifie si la collection contient tous les éléments de la collection spécifiée. La méthode isEmpty renvoie true si la collection est vide.

L'interface Collection fournit la méthode toArray(), qui renvoie une représentation matricielle pour la collection.

Certaines des méthodes de l'interface Collection ne peuvent pas être implémentées dans la sous-classe concrète. Dans ce cas, la méthode lancerait java.lang.UnsupportedOperationException, une sous-classe de RuntimeException. C'est une bonne conception que vous pouvez utiliser dans votre projet. Si une méthode n'a aucune signification dans la sous-classe, vous pouvez l'implémenter comme suit :

public void someMethod() {
lancer une nouvelle UnsupportedOperationException
("Méthode non prise en charge");
}

Le code ci-dessous donne un exemple d'utilisation des méthodes définies dans l'interface Collection.

package demo;
import java.util.*;

public class TestCollection {

    public static void main(String[] args) {
        ArrayList collection1 = new ArrayList();
        collection1.add("New York");
        collection1.add("Atlanta");
        collection1.add("Dallas");
        collection1.add("Madison");

        System.out.println("A list of cities in collection1:");
        System.out.println(collection1);

        System.out.println("\nIs Dallas in collection1? "   collection1.contains("Dallas"));

        collection1.remove("Dallas");
        System.out.println("\n"   collection1.size()   " cities are in collection1 now");

        Collection collection2 = new ArrayList();
        collection2.add("Seattle");
        collection2.add("Portland");
        collection2.add("Los Angeles");
        collection2.add("Atlanta");

        System.out.println("\nA list of cities in collection2:");
        System.out.println(collection2);

        ArrayList c1 = (ArrayList)(collection1.clone());
        c1.addAll(collection2);
        System.out.println("\nCities in collection1 or collection2: ");
        System.out.println(c1);

        c1 = (ArrayList)(collection1.clone());
        c1.retainAll(collection2);
        System.out.print("\nCities in collection1 and collection2: ");
        System.out.println(c1);

        c1 = (ArrayList)(collection1.clone());
        c1.removeAll(collection2);
        System.out.print("\nCities in collection1, but not in 2: ");
        System.out.println(c1);
    }

}

Une liste de villes dans la collection1 :
[New York, Atlanta, Dallas, Madison]
Dallas est-il dans la collection 1 ? vrai
3 villes sont en collection1 maintenant
Une liste des villes de la collection2 :
[Seattle, Portland, Los Angeles, Atlanta]
Villes dans la collection1 ou la collection2 :
[New York, Atlanta, Madison, Seattle, Portland, Los Angeles, Atlanta]
Villes dans collection1 et collection2 : [Atlanta]
Villes de la collection 1, mais pas de la collection 2 : [New York, Madison]

Le programme crée un objet de collection concret à l'aide de ArrayList (ligne 7) et appelle la méthode contains de l'interface Collection (ligne 16), méthode remove (ligne 18), méthode size (ligne 19), méthode addAll (ligne 31), méthode retainAll (ligne 36), et Méthode removeAll (ligne 41).

Pour cet exemple, nous utilisons ArrayList. Vous pouvez utiliser n'importe quelle classe concrète de Collection telle que HashSet, LinkedList, Vector et Stack pour remplacer ArrayList pour tester ces méthodes définies dans l'interface Collection.

Le programme crée une copie d'une liste de tableaux (lignes 30, 35, 40). Le but est de conserver la liste de tableaux d'origine intacte et d'utiliser sa copie pour effectuer les opérations addAll, retainAll et removeAll.

Toutes les classes concrètes du Java Collections Framework implémentent les interfaces java.lang.Cloneable et java.io.Serializing sauf que java.util.PriorityQueue n'implémente pas l'interface Cloneable. Ainsi, toutes les instances de Cloneable, à l'exception des files d'attente prioritaires, peuvent être clonées et toutes les instances de Cloneable peuvent être sérialisées.