Collections

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.

Le 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, s'appelle une carte.

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 Ensemblesstockent un groupe d'éléments non dupliqués.
• Les Listesstockent une collection ordonnée d'éléments.
• Empilezles objets stockés 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.
• PriorityQueuestocke 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 le Java Collections Framework sont regroupées dans le package java.util.

La conception du 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, on les appelle 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 pour 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 booléen. 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 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 pour utiliser les méthodes définies dans l'interface Collection.

package demo;
import java.util.*;

public class TestCollection {

    public static void main(String[] args) {
        ArrayList<String> 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<String> 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<String> c1 = (ArrayList<String>)(collection1.clone());
        c1.addAll(collection2);
        System.out.println("\nCities in collection1 or collection2: ");
        System.out.println(c1);

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

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

}

Une liste des villes de 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 en collection1 ou collection2 :
[New York, Atlanta, Madison, Seattle, Portland, Los Angeles, Atlanta]
Villes de la collection1 et de la collection2 : [Atlanta]
Villes de la collection 1, mais pas de la 2 : [New York, Madison]

Le programme crée un objet de collection concret à l'aide de ArrayList (ligne 7), et invoque 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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!