¿Cuál es la diferencia entre iterador e iterable y cómo usarlos?

Soy nuevo en Java y estoy realmente confundido con iterador e iterable. ¿Alguien puede explicarme y dar algunos ejemplos?

Un Iterable es una representación simple de una serie de elementos que pueden repetirse. No tiene ningún estado de iteración, como un “elemento actual”. En cambio, tiene un método que produce un Iterator .

Un Iterator es el objeto con estado de iteración. Le permite verificar si tiene más elementos utilizando hasNext() y pasar al siguiente elemento (si corresponde) utilizando next() .

Típicamente, un Iterable debería poder producir cualquier cantidad de Iterator válidos.

Una implementación de Iterable es una que proporciona un Iterator de sí mismo:

 public interface Iterable { Iterator iterator(); } 

Un iterador es una forma simple de permitir que algunos recorran una colección de datos sin privilegios de asignación (aunque con capacidad de eliminar).

 public interface Iterator { boolean hasNext(); E next(); void remove(); } 

Ver Javadoc .

Iterable: una interfaz que puede repetirse. Es decir, uno que tiene la noción de “conseguirme lo primero, ahora lo siguiente, y así sucesivamente, hasta que se nos acabe”.

Iterador: una interfaz que gestiona la iteración sobre un iterable. Es decir, realiza un seguimiento de dónde estamos en la iteración actual y sabe cuál es el siguiente elemento y cómo obtenerlo.

Para hacer un objeto iterable necesita emitir un objeto Iterator . Para hacer cumplir este contrato, se debe usar la interfaz Iterable. Contiene un método llamado iterator () y devuelve Iterator. Por lo tanto, cualquier clase que implemente Iterable devolverá un iterador.

 public interface Collection extends Iterable {} 

Por ejemplo, tomar cualquier colección. Una Colección es una interfaz que representa contenedor para series de elementos. Todas las colecciones como ArrayList, Vector implementa Collection y así Iterator.

Una ventaja de Iterable es que, cuando implementa Iterable, el objeto obtiene soporte para: cada syntax de bucle.

Si una colección es iterable, se puede iterar utilizando un iterador (y, en consecuencia, se puede usar en a para cada ciclo). El iterador es el objeto real que iterará a través de la colección.

La implementación de la interfaz Iterable permite que un objeto sea el objective de la instrucción “foreach”.

 class SomeClass implements Iterable {} class Main { public void method() { SomeClass someClass = new SomeClass(); ..... for(String s : someClass) { //do something } } } 

Iterator es una interfaz que tiene una implementación para iterar sobre los elementos. Iterable es una interfaz que proporciona Iterator.

La consideración más importante es si el artículo en cuestión debe poder atravesarse más de una vez. Esto se debe a que siempre puede rebobinar un Iterable al invocar iterator () nuevamente, pero no hay forma de rebobinar un Iterator.

Responderé la pregunta especialmente sobre ArrayList como ejemplo para ayudarlo a comprender mejor …

  1. La interfaz Iterable fuerza a sus subclases a implementar el método abstracto ‘iterator ()’.
 public interface Iterable { ... abstract Iterator iterator(); //Returns an 'Iterator'(not iterator) over elements of type T. ... } 
  1. La interfaz Iterator obliga a sus subclases a implementar el método abstracto ‘hasNext ()’ y ‘next ()’.
 public interface Iterator { ... abstract boolean hasNext(); //Returns true if the iteration has more elements. abstract E next(); //Returns the next element in the iteration. ... } 
  1. ArrayList implementa List, List implementa Collection y Collection implementa Iterable … Es decir, puedes ver la relación como

    ‘Iterable <- Collection <- List <- ArrayList'

. Y Iterable, Collection y List simplemente declaran el método abstracto ‘iterator ()’ y ArrayList solo lo implementa.

  1. Voy a mostrar el código fuente de ArrayList con el método ‘iterator ()’ de la siguiente manera para obtener información más detallada.

El método ‘iterator ()’ devuelve un objeto de la clase ‘Itr’ que implementa ‘Iterator’.

 public class ArrayList ... implements List, ... { ... public Iterator iterator() { return new Itr(); } private class Itr implements Iterator { ... public boolean hasNext() { return cursor != size; } @SuppressWarnings("unchecked") public E next() { checkForComodification(); int i = cursor; if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new ConcurrentModificationException(); cursor = i + 1; return (E) elementData[lastRet = i]; } ... } } 
  1. Algunos otros métodos o clases iterarán elementos de colecciones como ArrayList mediante el uso de iterador (Itr).

Aquí hay un ejemplo simple.

 public static void main(String[] args) { List list = new ArrayList<>(); list.add("a"); list.add("b"); list.add("c"); list.add("d"); list.add("e"); list.add("f"); Iterator iterator = list.iterator(); while (iterator.hasNext()) { String string = iterator.next(); System.out.println(string); } } 

Ahora, ¿está claro? 🙂

Básicamente hablando, ambos están muy relacionados entre sí.

Considere que Iterator es una interfaz que nos ayuda a atravesar una colección con la ayuda de algunos métodos indefinidos como hasNext (), next () y remove ()

Por otro lado, Iterable es otra interfaz que, si es implementada por una clase, fuerza a la clase a ser Iterable y es un objective para For-Each constructo. Solo tiene un método llamado iterator () que proviene de la interfaz de Iterator.

Cuando una colección es iterable, puede iterarse usando un iterador.

Para entenderlo, visite estos:

ITERABLE: http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/Iterable.java

ITERATOR http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Iterator.java

Considera un ejemplo con 10 manzanas. Cuando implementa Iterable, es como poner cada manzana en cuadros de 1 a 10 y devolver un iterador que se puede usar para navegar.

Al implementar el iterador, podemos obtener cualquier manzana, manzana en los siguientes cuadros, etc.

Entonces la implementación iterable le da a un iterador para navegar sus elementos. Aunque para navegar, el iterador necesita ser implementado.

Como se explica aquí , se introdujo el ” Iterable ” para poder usarlo en el ciclo foreach . Una clase que implementa la interfaz Iterable puede repetirse.

Iterator es una clase que gestiona la iteración sobre un Iterable . Mantiene un estado de dónde estamos en la iteración actual, y sabe cuál es el siguiente elemento y cómo obtenerlo.

Pregunta: ¿Diferencia entre Iterable e Iterador?
Ans:

iterable: está relacionado con forEach loop
iterador: está relacionado con la colección

El elemento objective del ciclo forEach debe ser iterable.
Podemos usar Iterator para obtener el objeto uno por uno de la Colección

Iterable presente en el paquete java.ḷang
Iterador presente en el paquete java.util

Contiene solo un iterador de método ()
Contiene tres métodos hasNext (), next (), remove ()

Introducido en la versión 1.5
Introducido en la versión 1.2

Además de las respuestas ColinD y Seeker .

En términos simples, Iterable e Iterator son ambas interfaces provistas en el Marco de Colección de Java.

Iterable

Una clase tiene que implementar la interfaz Iterable si quiere tener un bucle for-each para iterar sobre su colección. Sin embargo, el ciclo for-each solo se puede usar para recorrer la colección en la dirección hacia adelante y no podrá modificar los elementos en esta colección . Pero, si todo lo que quiere es leer los datos de los elementos, entonces es muy simple y gracias a la expresión lambda de Java a menudo es un trazador de líneas. Por ejemplo:

 iterableElements.forEach (x -> System.out.println(x) ); 

Iterador

Esta interfaz le permite iterar sobre una colección, obteniendo y eliminando sus elementos. Cada una de las clases de colección proporciona un método iterator () que devuelve un iterador al comienzo de la colección. La ventaja de esta interfaz sobre iterable es que con esta interfaz puede agregar, modificar o eliminar elementos en una colección . Pero, acceder a los elementos necesita un poco más de código que iterable. Por ejemplo:

 for (Iterator i = c.iterator(); i.hasNext(); ) { Element e = i.next(); //Get the element System.out.println(e); //access or modify the element } 

Fuentes:

  1. Java Doc Iterable
  2. Java Doc Iterator
    Intereting Posts