Quelles sont les différences entre la collection et la carte Java ?

Interface de collection

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 standards : le constructeur sans paramètre est utilisé pour créer une Collection vide, et le constructeur avec un paramètre Collection est utilisé pour créer une nouvelle Collection. Cette nouvelle Collection a les mêmes éléments que la. Collection passée. 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 :

Iterator it = collection.iterator(); // Obtenez un itérateur
while(it.hasNext()) {
Object obj = it.next(); // Obtenez 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 En utilisant 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 à l'ensemble 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. Ajoutez, 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 consiste à construire une liste synchronisée lors de la création de la liste :

List list = Collections.synchronizedList(new LinkedList(...));

ArrayList class

ArrayList implémente un tableau de taille variable. Il autorise tous les éléments, y compris null. ArrayList n'est pas synchronisé.

size, isEmpty, get, set le temps d'exécution de la méthode 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 est 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 est également non synchronisée.

Classe Vector

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 Stack

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.

Interface Set

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.
Évidemment, le constructeur Set a une contrainte selon laquelle le paramètre Collection transmis ne peut pas contenir d'éléments en double.
Veuillez noter : 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 cartographique

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 Hashtable

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.
Utilisez put(key, value) pour ajouter des données et get(key) pour supprimer des données. 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 Hashtable, et leurs clés sont respectivement "un", "deux" et "trois" :
Numéros de table de hachage = new Hashtable();
numbers. put("un", new Integer(1));
numbers.put("two", new Integer(2));
numbers.put("trois", new Integer(3));

Pour retirer un nombre, tel que 2, utilisez la clé correspondante :

Integer n = (Integer)numbers.get("two");
System.out.println("two = " + n);

En raison du fait qu'il s'agit d'une clé, l'objet déterminera la position de la valeur correspondante en calculant sa fonction de hachage, donc 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, plutôt que d’en écrire un seul. La table de hachage est synchrone.

Classe HashMap

HashMap est similaire à Hashtable, sauf que HashMap est asynchrone et autorise null, c'est-à-dire une valeur nulle et une 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 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.

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!