Différence entre l'énumération Java et l'itérateur

Quelle est la différence exacte entre ces deux interfaces? At Enumeration- il des avantages par rapport à l'utilisation Iterator? Si quelqu'un pouvait élaborer, un article de référence serait apprécié.

En regardant la spécification de l'API Java pour l' Iteratorinterface, il y a une explication des différences entre Enumeration:

Les itérateurs diffèrent des énumérations de deux manières:

• Les itérateurs permettent à l'appelant de supprimer des éléments de la collection sous-jacente pendant l'itération avec une sémantique bien définie.
• Les noms de méthodes ont été améliorés.

La ligne du bas est, à la fois Enumerationet Iteratordonnera des éléments successifs, mais Iteratorest améliorée de telle sorte que les noms de méthode sont plus courts et ont une removeméthode supplémentaire . Voici une comparaison côte à côte:

  Enumeration                     Iterator
  ----------------                ----------------
  hasMoreElement()                hasNext()
  nextElement()                   next()
  N/A                             remove()

Comme mentionné également dans les spécifications de l'API Java, pour les programmes plus récents, Iteratoril faut préférer Enumeration, car «Iterator remplace l'énumération dans le cadre des collections Java». (D'après les Iteratorspécifications.)

Les itérateurs sont rapides . c'est-à-dire que lorsqu'un thread modifie la collection par des opérations d'ajout / de suppression, tandis qu'un autre thread le traverse à travers un itérateur utilisant la hasNext() or next()méthode, l'itérateur échoue rapidement en lançant ConcurrentModificationException. Le comportement rapide des itérateurs ne peut être utilisé que pour détecter des bogues. Les énumérations retournées par les méthodes de classes telles que Hashtable, Vector ne sont pas rapides, ce qui est obtenu en synchronisant le bloc de code à l'intérieur de la nextElement()méthode qui verrouille l'objet Vector actuel, ce qui coûte beaucoup de temps.

"Officiellement", ils sont censés être similaires avec l'interface de l'itérateur prenant en charge des opérations supplémentaires (par exemple, la suppression). Généralement, la tendance est d'utiliser des itérateurs.

Voici des javadocs de l'interface d'énumération :

REMARQUE: la fonctionnalité de cette interface est dupliquée par l'interface Iterator. En outre, Iterator ajoute une opération de suppression facultative et a des noms de méthode plus courts. Les nouvelles implémentations devraient envisager d'utiliser Iterator de préférence à Enumeration.

Un fait simple mais non mentionné dans les réponses précédentes est qu'il Iterator<T>est utilisé avec Iterable<T>pour servir à interpréter la for(_type_ element:collection){...}structure.

Il y a trois différences fondamentales dans l'énumération et l'itérateur

Enumération
1. il est utilisé uniquement pour la classe de latence (par exemple Vector)

    Enumeration e = v.elements();  
    v is the object of `Vector` class

2. L'opération de lecture peut être effectuée, nous ne pouvons pas supprimer l'élément.
3. Deux méthodes sont disponibles

• public booléen hasNextElement ();
• objet public nextElement ();

Itérateur

1. il s'applique à toutes les collections

   Iterator itr = c.iterator();  
   where c is any `Collection` class

2. L'opération de lecture et de suppression peut être effectuée

3. Trois méthodes sont disponibles

   • public booléen hasNext ();
   • objet public suivant ();
   • public void remove ();

Limitation dans les deux

• Avancer uniquement vers l'avant
• Il n'y a aucune méthode pour Add objectetReplace object

Si vous écrivez votre propre classe de collection et que vous étendez l'une des classes existantes ou implémentez l'une des interfaces du framework Collections, vous n'avez fondamentalement pas d'autre choix que d'utiliser Iterator.

Si, pour une raison quelconque (à laquelle je ne pense pas), vous créez une classe de collection personnalisée qui ne se rapporte pas à java.util.Collection ou java.util.Map de quelque manière que ce soit, vous devez toujours implémenter Iterable afin que les gens puissent utiliser votre classe en boucle for.

La principale différence est que l'énumération n'expose pas la méthode remove (). De plus, Iterator ne permet pas une navigation et une modification simultanées sur un objet sous-jacent. Ils ont un contrôle pour voir s'il y a des modifications simultanées ou plus, et nécessitent donc plus de traitement. Les performances d'énumération sont donc pratiquement 50% plus rapides que celles d'itérateur. Si nous n'avons besoin que de la navigation en ignorant une telle synchronisation, utilisez simplement Enumeration.

1) La principale différence entre Iterator et Enumeration est la suppression de l'élément lors de la traversée de la collection. Iterator peut supprimer l'élément pendant le parcours de la collection car il dispose de la méthode remove (). L'énumération n'a pas de méthode remove ().

2) L'énumération est de nature à sécurité intégrée. Il ne lève pas ConcurrentModificationException si Collection est modifiée pendant la traversée. Iterator est par nature ultra-rapide. Il lève une exception ConcurrentModificationException si une collection est modifiée lors d'une itération autre que sa propre méthode remove ().

3) L'énumération est une interface héritée qui est utilisée pour parcourir Vector, Hashtable. Iterator n'est pas une interface héritée. Iterator peut être utilisé pour le parcours de HashMap, LinkedList, ArrayList, HashSet, TreeMap, TreeSet.

L'énumération ne peut être utilisée que pour la classe héritée (Vector, Stack ...), tandis que Iterator peut être utilisé pour tous.

L'itérateur et l'énumération sont utilisés pour récupérer les données, la différence est que l'énumération ne peut être utilisée que pour les classes héritées, c'est-à-dire vecteur / pile, tandis que les itérateurs peuvent être utilisés pour le reste. L'énumération peut également être utilisée pour l'ensemble de clés dans les cartes.