Diferencia entre Java Enumeration y Iterator

¿Cuál es la diferencia exacta entre estas dos interfaces? ¿La Enumeration tiene beneficios sobre el uso de Iterator ? Si alguien pudiera elaborar, un artículo de referencia sería apreciado.

En cuanto a la especificación de la API de Java para la interfaz del Iterator , hay una explicación de las diferencias entre la Enumeration :

Los iteradores difieren de las enumeraciones de dos maneras:

  • Los iteradores permiten que la persona que llama elimine elementos de la colección subyacente durante la iteración con una semántica bien definida.
  • Los nombres de los métodos han sido mejorados.

La conclusión es que tanto Enumeration como Iterator darán elementos sucesivos, pero Iterator se mejora de tal forma que los nombres de los métodos son más cortos y tiene un método de remove adicional. Aquí hay una comparación lado a lado:

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

Como también se menciona en las Especificaciones de API de Java, para los progtwigs más nuevos, se debe preferir Enumeration a Enumeration , ya que “Iterator toma el lugar de Enumeration en el marco de colecciones de Java”. (De las especificaciones del Iterator )

Los iteradores son rápidos . es decir, cuando un subproceso cambia la colección mediante operaciones de agregar / eliminar, mientras otro subproceso lo atraviesa mediante un iterador utilizando el hasNext() or next() , el iterador falla rápidamente lanzando ConcurrentModificationException . El comportamiento a prueba de fallas de los iteradores se puede usar solo para detectar errores. Las enumeraciones devueltas por los métodos de clases como Hashtable, Vector no son fail-fast que se logran al sincronizar el bloque de código dentro del método nextElement() que bloquea el objeto Vector actual que cuesta mucho tiempo.

“Oficialmente”, se supone que son similares con la interfaz del iterador que admite operaciones adicionales (por ejemplo, eliminación). Generalmente, la tendencia es usar iteradores.

Aquí está de la interfaz de enumeración javadocs :

NOTA: La funcionalidad de esta interfaz está duplicada por la interfaz de Iterator. Además, Iterator agrega una operación de eliminación opcional y tiene nombres de método más cortos. Las nuevas implementaciones deberían considerar el uso de Iterator con preferencia a la enumeración.

Un hecho simple pero no se ha mencionado en respuestas anteriores es que Iterator se usa con Iterable para servir en la interpretación for(_type_ element:collection){...} .

Hay tres diferencias básicas en la enumeración y el iterador

Enumeración
1. es uso solo para la clase heredada (por ejemplo, Vector )

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

2. La operación de lectura se puede realizar, no podemos eliminar el elemento.
3. Hay dos métodos disponibles

  • public boolean hasNextElement ();
  • public Object nextElement ();

Iterador

  1. es aplicable para toda la Colección

     Iterator itr = c.iterator(); where c is any `Collection` class 
  2. La operación de lectura y eliminación se puede realizar

  3. Tres métodos están disponibles

    • public boolean hasNext ();
    • Objeto público next ();
    • public void remove ();

Limitación en ambos

  • Mover solo hacia adelante
  • No hay ningún método para Add object y Replace object

Si está escribiendo su propia clase de colección, y está ampliando cualquiera de las clases existentes o implementando cualquiera de las interfaces del framework de colecciones, básicamente no tiene más remedio que usar Iterator.

Si por alguna razón (que no se me ocurre) está creando una clase de colección personalizada que no se relaciona con java.util.Collection o java.util.Map de ninguna manera, todavía debe implementar Iterable para que la gente pueda usar su clase en bucles.

El principal diferente es Enumeration no expone el método remove (). Además, el iterador no permite una navegación y modificación simultáneas en un objeto subyacente. Tienen un control para ver si hay modificaciones simultáneas o algo así y, por lo tanto, requiere más procesamiento. Entonces, el rendimiento de Enumeration es virtualmente 50% más rápido que Iterator. Si solo necesitamos navegación que ignore dicha sincronización, solo use Enumeration.

La enumeración se puede usar solo para la clase heredada (Vector, Pila …), mientras que Iterator se puede usar para todos.

Tanto el iterador como la enumeración se utilizan para recuperar los datos, la diferencia es que la enumeración solo se puede usar para clases heredadas, es decir, vector / stack, mientras que los iteradores se pueden usar para el rest. La enumeración también se puede usar para la clave establecida en los mapas.