Aperçu récapitulatif basé sur une collection de critiques Java

Auteur：Eve Cole Date de mise à jour：2024-11-18 12:48:01

Les collections en Java sont principalement concentrées en deux parties, l'une dans le package java.util et l'autre dans java.util.concurrent. Cette dernière est basée sur la première et définit certaines collections qui implémentent des fonctions de synchronisation.

Cet article se concentre principalement sur divers objets de collection sous java.util. Les objets de collection en Java peuvent être grossièrement divisés en trois catégories : Liste, Ensemble et Carte. Le diagramme UML correspondant est le suivant (y compris la plupart des objets de collection sous java.util) :

Aperçu des collections

Les collections List et Set dans Java proviennent de Collection. C'est un bon point d'entrée pour l'apprentissage des collections. Il inclut les opérations qui sont généralement requises dans les collections :

Ajouter des éléments : add/addAll
Effacer la collection : effacer
Supprimer des éléments : supprimer/supprimerTout
Déterminer si la collection contient un élément : contain/containsAll
Déterminez si la collection est vide : isEmpty
Calculer le nombre d'éléments dans une collection : taille
Convertir une collection en tableau : toArray
Obtenir l'itérateur : itérateur

Regardons un exemple simple. Le code suivant renverra une collection dont les éléments sont des entiers générés aléatoirement :

Copiez le code comme suit :

Collection statique privée initCollection()
{
Collection<Integer> collection = new ArrayList<Integer>();
Aléatoire r = nouveau Aléatoire();
pour (int i = 0; i < 5; i++)
{
collection.add(new Integer(r.nextInt(100)));
}

collecte de retour ;
}

Dans le processus d'opération sur des collections, la traversée est une opération fréquemment utilisée. Nous pouvons parcourir les collections de deux manières :

1) Utilisez des itérateurs pour parcourir la collection. Comme mentionné lors de la description de l'interface Collection ci-dessus, toutes les collections auront un itérateur que nous pouvons utiliser pour parcourir la collection.

Copiez le code comme suit :

accès vide statique privéCollectionByIterator (collection Collection<Integer>)
{
Itérateur<Integer> iterator = collection.iterator();
System.out.println("La valeur dans la liste :");
while(iterator.hasNext())
{
System.out.println(iterator.next());
}
}

2) Utilisez foreach pour parcourir la collection.

Copiez le code comme suit :

accès vide statique privéCollectionByFor (collection Collection<Integer>)
{
System.out.println("La valeur dans la liste :");
pour(Valeur entière : collection)
{
System.out.println(valeur);
}
}

Liste

List en Java est une extension efficace du tableau. C'est une structure qui peut contenir des éléments de n'importe quel type si les génériques ne sont pas utilisés, elle ne peut contenir que des éléments du type spécifié par les génériques. Par rapport aux tableaux, la capacité de List peut être étendue de manière dynamique.

Les éléments de la liste peuvent être répétés et les éléments à l'intérieur sont "ordonnés". Le "ordonné" ici ne signifie pas trier, mais signifie que nous pouvons spécifier la position d'un élément dans la collection.

Les objets de collection couramment utilisés dans List incluent : ArrayList, Vector et LinkedList, les deux premiers sont stockés sur la base de tableaux et les seconds sont stockés sur la base de listes chaînées. Parmi eux, Vector est thread-safe, et les deux autres ne le sont pas.

La liste peut contenir null, même si des génériques sont utilisés.

ArrayList est peut-être l'objet de collection le plus couramment utilisé. Dans l'exemple de code ci-dessus, nous l'utilisons également pour instancier un objet Collection, nous n'entrerons donc pas dans les détails ici.
Vecteur

Un exemple de vecteur est le suivant. Voyons d’abord comment générer et générer un vecteur :

Copiez le code comme suit :

vecteur de vide statique privéTest1()
{
List<Integer> list = new Vector<Integer>();
pour (int i = 0; i < 5; i++)
{
list.add(new Integer(100));
}
list.add(null);
System.out.println("la taille du vecteur est " + list.size());
System.out.println(liste);
}

Ses éléments incluent à la fois des éléments répétés et nuls. Les résultats de sortie sont les suivants :

Copiez le code comme suit :

la taille du vecteur est de 6
[100, 100, 100, 100, 100, nul]

L'exemple suivant illustre certaines méthodes courantes dans Vector :

Copiez le code comme suit :

vecteur de vide statique privéTest2()
{
Vecteur<Integer> list = new Vector<Integer>();
Aléatoire r = nouveau Aléatoire();
pour (int i = 0; i < 10; i++)
{
list.add(new Integer(r.nextInt(100)));
}
System.out.println("la taille du vecteur est " + list.size());
System.out.println(liste);
System.out.println(list.firstElement());
System.out.println(list.lastElement());
System.out.println(list.subList(3, 8));
List<Integer> temp = new ArrayList<Integer>();
pour(int je = 4; je < 7; je++)
{
temp.add(list.get(i));
}
list.retainAll(temp);
System.out.println("la taille du vecteur est " + list.size());
System.out.println(liste);
}

Sa sortie est la suivante :

Copiez le code comme suit :

la taille du vecteur est de 10
[39, 41, 20, 9, 29, 32, 54, 12, 94, 82]

[9, 29, 32, 54, 12]
la taille du vecteur est de 3
[29, 32, 54]

Liste liée

LinkedList utilise des listes chaînées pour stocker des données. Son exemple de code est le suivant :

Copiez le code comme suit :

Exemple de liste liée
vide statique privé linkedListTest1()
{
LinkedList<Integer> list = new LinkedList<Integer>();
Aléatoire r = nouveau Aléatoire();
pour (int i = 0; i < 10; i++)
{
list.add(new Integer(r.nextInt(100)));
}
list.add(null);
System.out.println("la taille de la liste chaînée est " + list.size());
System.out.println(liste);
System.out.println(list.element());
System.out.println(list.getFirst());
System.out.println(list.getLast());
System.out.println(list.peek());
System.out.println(list.peekFirst());
System.out.println(list.peekLast());
System.out.println(list.poll());
System.out.println(list.pollFirst());
System.out.println(list.pollLast());
System.out.println(list.pop());
list.push(nouveau Integer(100));
System.out.println("la taille de la liste chaînée est " + list.size());
System.out.println(liste);
}

Voici les méthodes couramment utilisées de LinkedList Comme vous pouvez le voir d'après les noms des méthodes, LinkedList peut également être utilisée pour implémenter des piles et des files d'attente.

Le résultat est le suivant :

Copiez le code comme suit :

la taille de la liste chaînée est de 11
[17, 21, 5, 84, 19, 57, 68, 26, 27, 47, nul]

nul

la taille de la liste chaînée est de 8
[100, 84, 19, 57, 68, 26, 27, 47]

Ensemble

Set est similaire à List, les deux sont utilisés pour stocker un seul élément et le nombre d'éléments individuels est incertain. Mais Set ne peut pas contenir d'éléments en double. Si deux éléments identiques sont insérés dans Set, ce dernier élément ne sera pas inséré.

Set peut être grossièrement divisé en deux catégories : Set non trié et Set trié. L'ensemble non trié comprend HashSet et LinkedHashSet, et l'ensemble trié fait principalement référence à TreeSet. Parmi eux, HashSet et LinkedHashSet peuvent contenir null.
Jeu de hachage

HashSet est une collection soutenue par une table de hachage, qui n'est pas thread-safe.

Regardons l'exemple suivant, qui est fondamentalement le même que le premier exemple avec Vector :

Copiez le code comme suit :

hashSetTest1() vide statique privé
{
Set<Integer> set = new HashSet<Integer>();

pour (int i = 0; i < 3; i++)
{
set.add(nouveau Integer(100));
}
set.add(null);

System.out.println("la taille de l'ensemble est " + set.size());
System.out.println(set);
}

Ici, HashSet contient à la fois des éléments répétés et nuls. Contrairement à Vector, le résultat est ici le suivant :

Copiez le code comme suit :

la taille de l'ensemble est de 2
[nul, 100]

Nous pouvons examiner en profondeur comment HashSet détermine si deux éléments sont des doublons. La méthode Equals est également définie dans Object. Pour les éléments du HashSet, il est jugé si les éléments sont égaux en fonction de la méthode Equals. Afin de le prouver, nous pouvons définir un type « anormal » :

Copiez le code comme suit :

Définir l'objet MyInteger

classeMonEntier
{
valeur entière privée ;

public MyInteger (valeur entière)
{
this.value = valeur ;
}

chaîne publique versString()
{
return String.valueOf(value);
}

public int hashCode()
{
renvoyer 1 ;
}

public booléen égal (Objet obj)
{
renvoie vrai ;
}
}

On peut voir que pour MyInteger, pour deux instances quelconques, nous le considérons comme inégal.

Voici la méthode de test correspondante :

Copiez le code comme suit :

hashSetTest2() vide statique privé
{
Set<MyInteger> set = new HashSet<MyInteger>();

pour (int i = 0; i < 3; i++)
{
set.add(nouveau MyInteger(100));
}

System.out.println("la taille de l'ensemble est " + set.size());
System.out.println(set);
}

Sa sortie est la suivante :

Copiez le code comme suit :

la taille de l'ensemble est de 3
[100, 100, 100]

Comme vous pouvez le voir, il y a désormais des éléments « en double » dans le HashSet, mais pour MyInteger, ils ne sont pas « les mêmes ».
Ensemble d'arbres

TreeSet est un Set qui prend en charge le tri et son interface parent est SortedSet.

Jetons d'abord un coup d'œil aux opérations de base de TreeSet :

Copiez le code comme suit :

treeSetTest1() vide statique privé
{
TreeSet<Integer> set = new TreeSet<Integer>();

Aléatoire r = nouveau Aléatoire();
pour (int i = 0; i < 5; i++)
{
set.add(new Integer(r.nextInt(100)));
}

System.out.println(set);
System.out.println(set.first());
System.out.println(set.last());
System.out.println(set.descendingSet());
System.out.println(set.headSet(new Integer(50)));
System.out.println(set.tailSet(new Integer(50)));
System.out.println(set.subSet(30, 60));
System.out.println(set.floor(50));
System.out.println(set.ceiling(50));
}

Sa sortie est la suivante :

Copiez le code comme suit :

[8, 42, 48, 49, 53]

[53, 49, 48, 42, 8]
[8, 42, 48, 49]
[53]
[42, 48, 49, 53]

Les éléments de TreeSet implémentent généralement l'interface Comparable. Par défaut, pour Integer, SortedList est stocké par ordre croissant. Nous pouvons également personnaliser la méthode Compare, comme le stockage par ordre décroissant.

Ensuite, nous redéfinissons d’abord Integer :

Copiez le code comme suit :

Définir l'objet MyInteger2
la classe MyInteger2 implémente Comparable
{
valeur int publique ;

public MyInteger2 (valeur int)
{
this.value = valeur ;
}

public int compareTo (Objet arg0)
{
MonEntier2 temp = (MonEntier2)arg0;
if (temp == null) renvoie -1 ;
si (temp.value > this.value)
{
renvoyer 1 ;
}
sinon si (temp.value <this.value)
{
renvoie -1 ;
}
renvoie 0 ;
}

public booléen égal (Objet obj)
{
return compareTo(obj) == 0;
}

chaîne publique versString()
{
return String.valueOf(value);
}
}

Voici le code du test :

Copiez le code comme suit :

treeSetTest2() vide statique privé
{
TreeSet<Integer> set1 = new TreeSet<Integer>();
TreeSet<MyInteger2> set2 = new TreeSet<MyInteger2>();
Aléatoire r = nouveau Aléatoire();
pour (int i = 0; i < 5; i++)
{
valeur int = r.nextInt(100);
set1.add (nouvel entier (valeur));
set2.add(nouveau MyInteger2(valeur));
}
System.out.println("Définir1 comme ci-dessous :");
System.out.println(set1);
System.out.println("Set2 comme ci-dessous :");
System.out.println(set2);
}

Le résultat de l’exécution du code est comme prévu, comme indiqué ci-dessous :

Copiez le code comme suit :

Set1 comme ci-dessous :
[13, 41, 42, 45, 61]
Set2 comme ci-dessous :
[61, 45, 42, 41, 13]

Carte

La carte stocke des « paires clé-valeur ». Semblable à Set, il existe deux types de cartes en Java : les cartes triées et non triées incluent HashMap, Hashtable et LinkedHashMap, et les cartes triées incluent TreeMap.
Carte non triée

HashMap et Hashtable sont stockés sous forme de tables de hachage. HashMap n'est pas thread-safe, mais Hashtable est thread-safe. Nous pouvons considérer HashMap comme une version « simplifiée » de Hashtable.

HashMap peut stocker null, que ce soit pour la clé ou la valeur. La table de hachage ne peut pas stocker null.

Indépendamment de HashMap ou de Hashtable, si l'on observe son constructeur, nous constaterons qu'il peut avoir deux paramètres : initialCapacity et loadFactor. Par défaut, initialCapacity est égal à 16 et loadFactor est égal à 0,75. Ceci est lié au nombre d'éléments pouvant être stockés dans la table de hachage. Lorsque le nombre d'éléments dépasse initialCapacity*loadFactor, la méthode rehash sera déclenchée pour développer la table de hachage. Si nous devons y insérer trop d’éléments, nous devons ajuster ces deux paramètres de manière appropriée.

Regardons d'abord un exemple de HashMap :

Copiez le code comme suit :

hashMapTest1() vide statique privé
{
Map<Integer,String> map = new HashMap<Integer, String>();

map.put(new Integer(1), "a");
map.put(new Integer(2), "b");
map.put(new Integer(3), "c");

System.out.println(carte);
System.out.println(map.entrySet());
System.out.println(map.keySet());
System.out.println(map.values());
}

Cela affichera les informations sur l'élément dans le HashMap, comme indiqué ci-dessous.

Copiez le code comme suit :

{1=a, 2=b, 3=c}
[1=a, 2=b, 3=c]
[1, 2, 3]
[une, b, c]

L'exemple suivant démontre null :

Copiez le code comme suit :

hashMapTest2() vide statique privé
{
Map<Integer,String> map = new HashMap<Integer, String>();

map.put(null, null);
map.put(null, null);
map.put(nouveau Integer(4), null);
map.put(new Integer(5), null);

System.out.println(carte);
System.out.println(map.entrySet());
System.out.println(map.keySet());
System.out.println(map.values());
}

Les résultats d'exécution sont les suivants :

Copiez le code comme suit :

{nul=nul, 4=nul, 5=nul}
[nul=nul, 4=nul, 5=nul]
[nul, 4, 5]
[nul, nul, nul]

Nous démontrons ensuite Hashtable, qui est fondamentalement identique aux deux exemples ci-dessus (le code ne sera pas développé) :

Copiez le code comme suit :

Exemple de table de hachage
hashTableTest1() vide statique privé
{
Map<Integer,String> table = new Hashtable<Integer, String>();

table.put(new Integer(1), "a");
table.put(new Integer(2), "b");
table.put(new Integer(3), "c");

System.out.println(table);
System.out.println(table.entrySet());
System.out.println(table.keySet());
System.out.println(table.values());
}

hashTableTest2() vide statique privé
{
Map<Integer,String> table = new Hashtable<Integer, String>();

table.put(null, null);
table.put(null, null);
table.put(nouveau Integer(4), null);
table.put(nouveau Integer(5), null);

System.out.println(table);
System.out.println(table.entrySet());
System.out.println(table.keySet());
System.out.println(table.values());
}

Les résultats d'exécution sont les suivants :

Copiez le code comme suit :

{3=c, 2=b, 1=a}
[3=c, 2=b, 1=a]
[3, 2, 1]
[c, b, a]
Exception dans le thread "principal" java.lang.NullPointerException
sur java.util.Hashtable.put (source inconnue)
à sample.collections.MapSample.hashTableTest2(MapSample.java:61)
à sample.collections.MapSample.main(MapSample.java:11)

On voit clairement que lorsque nous essayons d'insérer null dans la table de hachage, une exception de pointeur null est signalée.
Carte de tri

Sorting Map fait principalement référence à TreeMap, qui a une complexité temporelle de O(log(n)) lors de l'ajout, de la suppression et de la recherche d'éléments. Ce n’est pas thread-safe.

Ses caractéristiques sont très similaires à TreeSet, je n’entrerai donc pas dans les détails ici.