2009-06-04 15 views
102

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

+3

Utilicé una búsqueda en Google y el primer resultado fue una discusión interesante en JavaRanch sobre [Enumeración vs iterador] (http://www.coderanch.com/t/202139/Performance/java/Enumeration-vs-Iterator) –

Respuesta

124

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

Iteradores difieren de enumeraciones de dos maneras:

  • iteradores permiten que la persona que llama para eliminar elementos de la colección subyacente durante la iteración con semántica bien definida .
  • Se han mejorado los nombres de los métodos.

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

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

Como también se menciona en las especificaciones API Java, para programas nuevos, Iterator conviene preferir el Enumeration, como "iterador toma el lugar de empadronamiento en el marco de las colecciones de Java " (De las especificaciones Iterator.)

+6

Creo que falta una explicación de esta respuesta con respecto a la concurrencia. –

+0

@Paul_Draper: las ediciones no deberían agregar un nuevo significado a la publicación, para eso están los comentarios. – Emil

+2

@coobird ¿Estás seguro de que "las enumeraciones suelen ser más rápidas"? ya que Enumeration tiene "sincronizar bloque de código dentro del nextElement()" Y no tenemos sincronización en Iterators que causa la ConcurrentModificationException rit ?? ¿Llamamos que los iteradores son generalmente más rápidos y las enumeraciones son un poco más seguras? ?? –

11

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

Aquí es de the enumeration interface javadocs:

NOTA: La funcionalidad de esta interfaz se duplica por la interfaz iterador. 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 en la preferencia para la enumeración.

2

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

Si por alguna razón (que no puedo pensar en) va a crear una clase de colección personalizada que no se refiere a java.util.Collection o java.util.Map de cualquier manera, usted debe todavía implemente Iterable para que las personas puedan usar su clase para bucles.

2

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.

+0

Es cierto que Enumeration "no" expone el método remove(), pero tampoco presta atención a la invocación de la API remove() de Collection. Por ejemplo, el siguiente código simplemente se imprimirá: AAA, CCC, EEE. ------------------------------------------------ ----- Vector v = nuevo Vector (6); v.add ("AAA"); v.add ("BBB"); v.add ("CCC"); v.add ("DDD"); v.add ("EEE"); v.add ("FFF"); Enumeración es = v.elements(); while (en.hasMoreElements()) String value = (String) en.nextElement(); System.out.println (valor); v.remove (valor); – javauser71

-1

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

+0

¿Dónde viste que puedes usar la enumeración para los conjuntos clave de mapa? – Kutzi

31

Iterators son fail-fast. es decir, cuando un hilo cambia la colección mediante operaciones de agregar/eliminar, mientras que otro hilo lo está atravesando mediante un iterador usando el método 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 logra sincronizando el bloque de código dentro del método nextElement() que bloquea el objeto Vector actual que cuesta mucho tiempo.

+4

Solo parcialmente cierto: este comportamiento no está definido en la interfaz, depende de la implementación del iterador. Es cierto que las implementaciones de colecciones 'antiguas' en java.util (HashSet, ArrayList, etc.) exhiben este comportamiento. Sin embargo, las colecciones 'simultáneas' más nuevas nunca emitirán una ConcurrentModificationException, sino que atravesarán la colección en el momento de la creación del iterador. Otras implementaciones pueden mostrar un comportamiento diferente. – Kutzi

+0

También vale la pena señalar: "Tenga en cuenta que no se puede garantizar el comportamiento a prueba de fallos, ya que, en términos generales, es imposible hacer ninguna garantía en presencia de modificaciones concurrentes no sincronizadas. Las operaciones a prueba rápida lanzan ConcurrentModificationException sobre la base del mejor esfuerzo. Por lo tanto, sería incorrecto escribir un programa que dependiera de esta excepción para su corrección: ConcurrentModificationException debería usarse solo para detectar errores ". http://docs.oracle.com/javase/7/docs/api/java/util/ConcurrentModificationException.html – Kutzi

6

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

4

Hay tres básica diferencia en Enumeración y iterador

Enumeración
1. es el uso para la única clase lagacy (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. Dos Método están disponibles

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

iterador

  1. es aplicable para todos Colección

    Iterator itr = c.iterator(); 
    where c is any `Collection` class 
    
  2. Lea y quitar operación se puede realizar

  3. Tres Método están disponibles

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

de limitación de tanto en

  • moverse sólo hacia adelante dirección
  • No hay ningún método para Add object y Replace object
0

enumeración puede ser utilizado sólo para el legado clase (Vector, Pila ...), mientras que Iterator se puede usar para todos.

Cuestiones relacionadas