¿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?

Una Iterablees una representación simple de una serie de elementos que se pueden iterar. No tiene ningún estado de iteración, como un "elemento actual". En cambio, tiene un método que produce unIterator .

An Iteratores el objeto con estado de iteración. Le permite verificar si tiene más elementos usando hasNext()y pasar al siguiente elemento (si lo hay) usando next().

Típicamente, un Iterabledebería ser capaz de producir cualquier número de Iterators válidos .

Una implementación de Iterablees aquella que proporciona una Iteratorde sí misma:

public interface Iterable<T>
{
    Iterator<T> iterator();
}

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

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

Ver Javadoc .

Contestaré la pregunta especialmente sobre ArrayList como ejemplo para ayudarlo a comprender mejor.

1. La interfaz iterable obliga a sus subclases a implementar el método abstracto 'iterator ()'.

public interface Iterable {
  ...
  abstract Iterator<T> iterator(); //Returns an 'Iterator'(not iterator) over elements of type T.
  ...
}

2. La interfaz del iterador 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.
  ...
}

3. ArrayList implementa Lista, Lista extiende Colección y Colección extiende Iterable. Es decir, podría ver la relación como

   'Iterable <- Colección <- Lista <- ArrayList'

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

4. 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<E> ... implements List<E>, ...
{
  ...
  public Iterator<E> iterator() {
              return new Itr();
  }


  private class Itr implements Iterator<E> {
          ...

          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];
          }
          ...
  }
}

5. Algunos otros métodos o clases iterarán elementos de colecciones como ArrayList haciendo uso de Iterator (Itr).

Aquí hay un ejemplo simple.

public static void main(String[] args) {

    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("e");
    list.add("f");

    Iterator<String> iterator = list.iterator();
    while (iterator.hasNext()) {
        String string = iterator.next();
        System.out.println(string);
    }
}

Ahora, ¿está claro? :)

Si una colección es iterable, se puede iterar usando un iterador (y, en consecuencia, se puede usar en un 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 objetivo de la declaración "foreach".

class SomeClass implements Iterable<String> {}

class Main 
{
  public void method()
  {
     SomeClass someClass = new SomeClass();
     .....

    for(String s : someClass) {
     //do something
    }
  }
}

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

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

Como se explica aquí , se introdujo el " Iterable " para poder usarlo en el foreachbucle. Una clase implementando el 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.

Considere un ejemplo con 10 manzanas. Cuando implementa Iterable, es como poner cada manzana en cuadros del 1 al 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.

Pregunta: ¿Diferencia entre Iterable e Iterator?
Respuesta:

iterable: está relacionado con cada
iterador de bucle : está relacionado con la colección

El elemento de destino 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. packageang Iterator
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

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

Considere Iterator como 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, obliga a la clase a ser Iterable y es un objetivo para la construcción For-Each. Tiene solo un método llamado iterator () que proviene de la interfaz Iterator.

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

Para entender, 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

Sé que esta es una vieja pregunta, pero para cualquiera que lea esto y que esté atrapado en la misma pregunta y que pueda verse abrumado con toda la terminología, aquí hay una analogía buena y simple para ayudarlo a comprender esta distinción entre iterables e iteradores:

Piensa en una biblioteca pública. Vieja escuela. Con libros de papel. Sí, ese tipo de biblioteca.

Un estante lleno de libros sería como un iterable. Puedes ver la larga fila de libros en el estante. Puede que no sepa cuántos, pero puede ver que es una larga colección de libros.

El bibliotecario sería como el iterador. Puede señalar un libro específico en cualquier momento. Puede insertar / eliminar / modificar / leer el libro en el lugar donde está apuntando. Señala, en secuencia, cada libro a la vez cada vez que gritas "¡siguiente!" a él. Entonces, normalmente le preguntarías: "¿Siguiente?", Y él dirá "sí", a lo que tú dirás "¡siguiente!" y él señalará el próximo libro. También sabe cuándo ha llegado al final del estante, de modo que cuando pregunta: "¿Siguiente?" él dirá "no".

Sé que es un poco tonto, pero espero que esto ayude.

Además de las respuestas ColinD y Seeker .

En términos simples, Iterable e Iterator son interfaces proporcionadas en Java Framework Collection.

Iterable

Una clase tiene que implementar la interfaz Iterable si quiere tener un ciclo 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 de esta colección . Pero, si todo lo que desea 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, obtener y eliminar sus elementos. Cada una de las clases de colección proporciona un método iterator () que devuelve un iterador al inicio 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, el acceso 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

Iterable se introdujeron para usar en cada bucle en java

public interface Collection<E> extends Iterable<E>  

Iteratores 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.