Préface
Dans l’exemple de code d’analyse du pool de connexions à la base de données, vous pouvez voir que l’énumération est utilisée pour parcourir la collection Vector. Plus tard, j'ai cherché des informations pour voir quelles méthodes peuvent être utilisées pour parcourir les classes de collection. J'ai trouvé les exemples suivants sur Internet d'utilisation d'Enumeration et d'Iterator pour parcourir les classes de collection. Mais cet exemple indique que Enumeration est plus efficace que Iterator. En fait, ce n'est pas le cas . Le test temporel dans cet exemple est trop unilatéral car la quantité de données est trop petite. À mesure que le nombre de données augmente, l’efficacité entre les deux se rapproche de plus en plus, sans que le rapport des multiples n’apparaisse. De plus, Iterator est désormais couramment utilisé pour parcourir les classes de collection. Seuls ceux qui déclarent spécifiquement qu'Enumeration doit être utilisé utiliseront cette classe pour parcourir les collections.
Exemple de code
Copiez le code comme suit :
paquet edu.sjtu.erplab.hash ;
importer java.util.Enumeration ;
importer java.util.Hashtable ;
importer java.util.Iterator ;
importer java.util.Map.Entry ;
//Une instance de table de hachage de traversée
classe publique TraverseHashTable {
public static void main (String[] arguments) {
//Initialiser et créer une table de hachage
Hashtable<String, String> ht = new Hashtable<String, String>();
pour (int je = 0; je < 10000; i++) {
ht.put("Key=" + i, "Val=" + i);
}
// 1. Utiliser l'énumération
démarrage long = System.currentTimeMillis();
Enumeration<String> en = ht.keys();//Utiliser l'énumération pour obtenir la clé
while (en.hasMoreElements()) {
fr.nextElement();
}
extrémité longue = System.currentTimeMillis();
System.out.println("Coûts des clés d'énumération " + (fin - début)
+ " millisecondes");
// 2. Utiliser l'énumération
start = System.currentTimeMillis();
Enumeration<String> en2 = ht.elements();//Utiliser l'énumération pour obtenir cette paire clé-valeur
while (en2.hasMoreElements()) {
en2.nextElement();
}
fin = System.currentTimeMillis();
System.out.println("Coûts des éléments d'énumération " + (fin - début)
+ " millisecondes");
// 3. Itérateur
start = System.currentTimeMillis();
Iterator<String> it = ht.keySet().iterator();//Utiliser un itérateur pour obtenir cette clé
tandis que (it.hasNext()) {
it.next();
}
fin = System.currentTimeMillis();
System.out.println("Coûts du keySet de l'itérateur " + (fin - début)
+ " millisecondes");
// 4. Itérateur
start = System.currentTimeMillis();
Iterator<Entry<String, String>> it2 = ht.entrySet().iterator();//Utilisez un itérateur pour obtenir cette paire clé-valeur
tandis que (it2.hasNext()) {
it2.next();
}
fin = System.currentTimeMillis();
System.out.println("Entrée de l'itérateurDéfinir les coûts " + (fin - début)
+ " millisecondes");
}
}
Interface obsolète : Énumération
L'interface Enumeration a été introduite dans JDK 1.0 et constitue la meilleure interface de sortie d'itération lorsque Vector a été utilisé pour la première fois (ArrayList est désormais recommandé), l'interface Enumeration a été utilisée pour la sortie. Bien qu'Enumeration soit une ancienne classe, la classe Enumeration a été étendue après JDK1.5 pour ajouter des applications d'opération génériques.
Les méthodes couramment utilisées de l'interface Enumeration incluent hasMoreElements() (pour déterminer s'il existe une valeur suivante) et nextElement() (pour supprimer l'élément actuel. Les fonctions de ces méthodes sont similaires à celles d'Iterator, sauf qu'il existe une méthode pour). supprime les données dans Iterator, mais cette interface n'a pas de fonction de suppression.
Pourquoi continuer à utiliser l’interface Enumération ?
Les interfaces Enumeration et Iterator ont des fonctions similaires, et Iterator a plus de fonctions qu'Enumeration, alors pourquoi utiliser Enumeration ? En effet, le développement de Java a pris du temps et certains systèmes ou méthodes plus anciens dans les bibliothèques de classes utilisent toujours l'interface Enumeration. Par conséquent, pour des raisons de compatibilité, Enumeration doit toujours être utilisée.
Sous-classes courantes de l'interface List
Les sous-classes couramment utilisées de l'interface List incluent ArrayList et Vector. Les deux présentent de nombreuses similitudes. Une comparaison entre les deux est donnée ci-dessous.