Récemment, j'ai vu une très bonne description du framework de collection dans un livre J2EE. Je l'ai filtré et publié pour le partager avec tout le monde. Le framework de collection fournit des interfaces et des classes pour gérer les collections d'objets. Voici la description de chaque composant.
Interface de collecte
Collection est l'interface de collection la plus basique. Une collection représente un ensemble d'objets, c'est-à-dire les éléments de la collection. Certaines collections autorisent des éléments identiques et d’autres non. Certains le font et d'autres non. Le SDK Java ne fournit pas de classes héritant directement de Collection. Les classes fournies par le SDK Java sont toutes des « sous-interfaces » qui héritent de Collection, telles que List et Set.
Toutes les classes qui implémentent l'interface Collection doivent fournir deux constructeurs standard : un constructeur sans paramètre pour créer une collection vide et un constructeur avec paramètre Collection pour créer une nouvelle collection. La collection d'entrée a les mêmes éléments. Ce dernier constructeur permet à l'utilisateur de copier une collection.
Comment parcourir chaque élément de Collection ? Quel que soit le type réel de Collection, il prend en charge une méthode iterator(), qui renvoie un itérateur pouvant être utilisé pour accéder à chaque élément de la Collection un par un. L'utilisation typique est la suivante :
Copiez le code comme suit :
Itérateur it = collection.iterator(); // Récupère un itérateur
while(it.hasNext()) {
Object obj = it.next(); // Récupère l'élément suivant
}
Les deux interfaces dérivées de l'interface Collection sont List et Set.
Interface de liste La liste est une collection ordonnée. Grâce à cette interface, vous pouvez contrôler avec précision la position d'insertion de chaque élément. Les utilisateurs peuvent accéder aux éléments de la liste à l'aide de l'index (la position de l'élément dans la liste, similaire à un indice de tableau), qui est similaire à un tableau Java.
Contrairement au Set mentionné ci-dessous, List autorise les mêmes éléments.
En plus de la méthode iterator() nécessaire à l'interface Collection, List fournit également une méthode listIterator(), qui renvoie une interface ListIterator. Par rapport à l'interface Iterator standard, ListIterator a quelques méthodes supplémentaires add() et autres, permettant des ajouts. Supprimez, définissez des éléments et avancez ou reculez.
Les classes courantes qui implémentent l'interface List sont LinkedList, ArrayList, Vector et Stack.
Classe LinkedList LinkedList implémente l'interface List et autorise les éléments nuls. De plus, LinkedList fournit des méthodes supplémentaires d'obtention, de suppression et d'insertion en tête ou à la fin de LinkedList. Ces opérations permettent à LinkedList d'être utilisée comme pile, file d'attente ou deque.
Notez que LinkedList n'a pas de méthodes synchronisées. Si plusieurs threads accèdent à une liste en même temps, ils doivent implémenter eux-mêmes la synchronisation des accès. Une solution de contournement consiste à construire une liste synchronisée lors de la création de la liste :
Liste liste = Collections.synchronizedList(new LinkedList(...));
Classe ArrayList ArrayList implémente des tableaux de taille variable. Il autorise tous les éléments, y compris null. ArrayList n'est pas synchronisé.
Le temps d’exécution des méthodes size, isEmpty, get et set est constant. Cependant, le coût de la méthode add est une constante amortie et l’ajout de n éléments nécessite un temps O(n). D'autres méthodes ont une durée d'exécution linéaire.
Chaque instance d'ArrayList a une capacité (Capacity), qui correspond à la taille du tableau utilisé pour stocker les éléments. Cette capacité augmente automatiquement à mesure que de nouveaux éléments sont ajoutés, mais l'algorithme de croissance n'est pas défini. Lorsqu'un grand nombre d'éléments doivent être insérés, la méthode EnsureCapacity peut être appelée pour augmenter la capacité de l'ArrayList avant l'insertion afin d'améliorer l'efficacité de l'insertion.
Comme LinkedList, ArrayList n'est pas non plus synchronisé.
Classe de vecteur Vector est très similaire à ArrayList, mais Vector est synchronisé. Bien que l'itérateur créé par Vector ait la même interface que l'itérateur créé par ArrayList, étant donné que Vector est synchronisé, lorsqu'un itérateur est créé et utilisé, un autre thread modifie l'état du vecteur (par exemple, en ajoutant ou en supprimant un élément). , ConcurrentModificationException sera levée lors de l'appel de la méthode Iterator, l'exception doit donc être interceptée.
Classe de pile Stack hérite de Vector et implémente une pile dernier entré, premier sorti. Stack fournit 5 méthodes supplémentaires qui permettent d'utiliser Vector comme pile. Les méthodes de base push et pop, ainsi que la méthode peek, placent l'élément en haut de la pile, la méthode vide teste si la pile est vide et la méthode de recherche détecte la position d'un élément dans la pile. La pile est une pile vide après sa création.
Définir l'interface Set est une collection qui ne contient pas d'éléments en double, c'est-à-dire que deux éléments e1 et e2 ont e1.equals(e2)=false et Set a au plus un élément nul.
De toute évidence, le constructeur Set a une contrainte selon laquelle le paramètre Collection transmis ne peut pas contenir d'éléments en double.
Remarque : les objets mutables doivent être manipulés avec soin. Si un élément mutable dans un Set change d'état, provoquant Object.equals(Object)=true, cela entraînera des problèmes.
Interface Map <BR>Veuillez noter que Map n'hérite pas de l'interface Collection Map fournit un mappage clé-valeur. Une Map ne peut pas contenir la même clé et chaque clé ne peut mapper qu’une seule valeur. L'interface Map propose trois types de vues d'ensemble. Le contenu de la carte peut être considéré comme un ensemble d'ensembles de clés, un ensemble d'ensembles de valeurs ou un ensemble de mappages clé-valeur.
Classe de table de hachage Hashtable hérite de l'interface Map et implémente une table de hachage de mappage clé-valeur. Tout objet non nul peut être utilisé comme clé ou valeur.
Pour ajouter des données, utilisez put(key, value) et pour supprimer des données, utilisez get(key). Le coût en temps de ces deux opérations de base est constant.
Hashtable ajuste les performances via deux paramètres : la capacité initiale et le facteur de charge. Habituellement, le facteur de charge par défaut de 0,75 permet d'obtenir un meilleur équilibre entre le temps et l'espace. L'augmentation du facteur de charge peut économiser de l'espace, mais le temps de recherche correspondant augmentera, ce qui affectera les opérations telles que l'extraction et la mise en place.
Un exemple simple d'utilisation de Hashtable est le suivant : Mettez 1, 2 et 3 dans la table de hachage, et leurs clés sont respectivement « un », « deux » et « trois » :
Copiez le code comme suit :
Numéros de table de hachage = new Hashtable();
nombres.put("un", new Integer(1));
nombres.put("deux", new Integer(2));
nombres.put("trois", new Integer(3));
Pour récupérer un nombre, tel que 2, utilisez la clé correspondante :
Entier n = (Integer)numbers.get("deux");
System.out.println("deux =" + n);
Puisque l'objet utilisé comme clé déterminera la position de la valeur correspondante en calculant sa fonction de hachage, tout objet utilisé comme clé doit implémenter les méthodes hashCode et equals. Les méthodes hashCode et equals héritent de la classe racine Object. Si vous utilisez une classe personnalisée comme clé, soyez très prudent Selon la définition de la fonction de hachage, si les deux objets sont identiques, c'est-à-dire obj1.equals(. obj2)=true, alors leur hashCode doit être le même, mais si deux objets sont différents, leur hashCode n'est pas nécessairement différent. Si le hashCode de deux objets différents est le même, ce phénomène est appelé conflit. le temps nécessaire à l'exploitation de la table de hachage augmente. Par conséquent, essayez de définir une méthode hashCode() bien définie pour accélérer les opérations de la table de hachage.
Si le même objet a un hashCode différent, le fonctionnement de la table de hachage aura des résultats inattendus (la méthode get attendue renvoie null. Pour éviter ce problème, vous n'avez qu'à vous rappeler d'une chose : remplacer la méthode equals et la méthode hashCode en même temps). temps. N’écrivez pas un seul d’entre eux.
La table de hachage est synchrone.
Classe HashMap HashMap est similaire à Hashtable, sauf que HashMap est asynchrone et autorise null, c'est-à-dire valeur nulle et clé nulle. , mais lorsque l'on traite HashMap comme une collection (la méthode values() peut renvoyer une collection), la surcharge temporelle de ses sous-opérations d'itération est proportionnelle à la capacité du HashMap. Par conséquent, si les performances des opérations itératives sont très importantes, ne définissez pas la capacité initiale de HashMap trop élevée ni le facteur de charge trop bas.
Classe WeakHashMap WeakHashMap est un HashMap amélioré qui implémente des « références faibles » aux clés. Si une clé n'est plus référencée en externe, la clé peut être recyclée par GC.
Résumé <BR>Si des opérations telles que des piles et des files d'attente sont impliquées, vous devriez envisager d'utiliser List. Si vous devez insérer et supprimer rapidement des éléments, vous devez utiliser LinkedList. Si vous avez besoin d'un accès aléatoire rapide aux éléments, vous devez utiliser ArrayList.
Si le programme se trouve dans un environnement monothread ou si l'accès n'est effectué que dans un seul thread, envisagez des classes asynchrones, qui sont plus efficaces. Si plusieurs threads peuvent gérer une classe en même temps, des classes synchronisées doivent être utilisées.
Portez une attention particulière au fonctionnement de la table de hachage. L'objet utilisé comme clé doit remplacer correctement les méthodes equals et hashCode.
Essayez de renvoyer l'interface plutôt que le type réel, par exemple en renvoyant List au lieu de ArrayList, de sorte que si vous devez remplacer ArrayList par LinkedList à l'avenir, le code client n'a pas besoin d'être modifié. C'est de la programmation pour l'abstraction.
