Qual é a diferença entre iterador e iterável e como usá-los?

Eu sou novo em Java e estou realmente confuso com iterador e iterável. Alguém pode me explicar e dar alguns exemplos?

An Iterableé uma representação simples de uma série de elementos que podem ser iterados. Ele não possui nenhum estado de iteração, como um "elemento atual". Em vez disso, ele tem um método que produz umIterator .

An Iteratoré o objeto com estado de iteração. Permite verificar se há mais elementos usando hasNext()e ir para o próximo elemento (se houver) usando next().

Normalmente, um Iterabledeve poder produzir qualquer número de Iterators válidos .

Uma implementação de Iterableé aquela que fornece um Iteratorde si:

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

Um iterador é uma maneira simples de permitir que alguns passem por uma coleta de dados sem privilégios de atribuição (embora com capacidade de remoção).

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

Veja Javadoc .

Vou responder à pergunta especialmente sobre ArrayList como um exemplo, a fim de ajudá-lo a entender melhor.

1. A interface iterável força suas subclasses a implementar o método abstrato 'iterator ()'.

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

2. A interface Iterator força suas subclasses a implementar o método abstrato 'hasNext ()' e '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 List, List extende Collection e Collection extende Iterable. Ou seja, você pode ver o relacionamento como

   'Iterável <- Coleção <- Lista <- ArrayList'

. E Iterable, Collection e List apenas declaram o método abstrato 'iterator ()' e somente o ArrayList o implementa.

4. Vou mostrar o código-fonte ArrayList com o método 'iterator ()' da seguinte maneira para obter informações mais detalhadas.

O método 'iterator ()' retorna um objeto da classe '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. Alguns outros métodos ou classes iterarão elementos de coleções como ArrayList usando o Iterator (Itr).

Aqui está um exemplo simples.

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);
    }
}

Agora está claro? :)

Se uma coleção é iterável, ela pode ser iterada usando um iterador (e, consequentemente, pode ser usada em uma para cada loop.) O iterador é o objeto real que iterará na coleção.

A implementação da interface Iterável permite que um objeto seja o destino da instrução "foreach".

class SomeClass implements Iterable<String> {}

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

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

O iterador é uma interface que possui implementação para iterar sobre elementos. Iterável é uma interface que fornece o Iterator.

A consideração mais importante é se o item em questão deve poder ser percorrido mais de uma vez. Isso ocorre porque você sempre pode rebobinar um Iterable chamando iterator () novamente, mas não há como rebobinar um Iterator.

Conforme explicado aqui , o " Iterable " foi introduzido para poder ser usado no foreachloop. Uma classe implementando a interface Iterable pode ser repetida.

Iterator é uma classe que gerencia a iteração em um Iterable . Ele mantém um estado de onde estamos na iteração atual e sabe qual é o próximo elemento e como obtê-lo.

Considere um exemplo com 10 maçãs. Quando implementa o Iterable, é como colocar cada maçã em caixas de 1 a 10 e retornar um iterador que pode ser usado para navegar.

Ao implementar o iterador, podemos obter qualquer maçã, maçã nas próximas caixas, etc.

Portanto, implementar iterável fornece um iterador para navegar por seus elementos, embora, para navegar, o iterador precise ser implementado.

Pergunta: Diferença entre Iterable e Iterator?
Resp:

iterável: Está relacionado ao
iterador de loop forEach : Está relacionado à Coleção

O elemento de destino do loop forEach deve ser iterável.
Podemos usar o Iterator para obter o objeto um a um da coleção

Presente iterável no pacote java.ḷang
Iterador presente no pacote java.util

Contém apenas um iterador de método ()
Contém três métodos hasNext (), next (), remove ()

Introduzido na versão 1.5
Introduzido na versão 1.2

Basicamente falando, os dois estão intimamente relacionados.

Considere o Iterator como uma interface que nos ajuda a percorrer uma coleção com a ajuda de alguns métodos indefinidos, como hasNext (), next () e remove ()

Por outro lado, Iterable é outra interface que, se implementada por uma classe, força a classe a ser Iterável e é um destino para a construção For-Each. Ele possui apenas um método chamado iterator () que vem da própria interface do Iterator.

Quando uma coleção é iterável, pode ser iterada usando um iterador.

Para entender, visite estes:

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

Sei que essa é uma pergunta antiga, mas para quem está lendo essa pergunta e está sobrecarregada com toda a terminologia, aqui está uma analogia boa e simples para ajudá-lo a entender essa distinção entre iteráveis ​​e iteradores:

Pense em uma biblioteca pública. Moda antiga. Com livros de papel. Sim, esse tipo de biblioteca.

Uma prateleira cheia de livros seria como uma iterável. Você pode ver a longa fila de livros na prateleira. Você pode não saber quantos, mas pode ver que é uma longa coleção de livros.

O bibliotecário seria como o iterador. Ele pode apontar para um livro específico a qualquer momento. Ele pode inserir / remover / modificar / ler o livro no local para onde está apontando. Ele aponta, em sequência, para cada livro de cada vez, toda vez que você grita "próximo!" para ele. Então, você normalmente pergunta a ele: "tem o próximo?", E ele diz "sim", ao qual você diz "próximo!" e ele apontará para o próximo livro. Ele também sabe quando chegou ao fim da prateleira, de modo que quando você pergunta: "tem o próximo?" ele vai dizer "não".

Eu sei que é um pouco bobo, mas espero que isso ajude.

Além das respostas do ColinD e do Seeker .

Em termos simples, Iterable e Iterator são interfaces fornecidas no Java Framework Collection.

Iterável

Uma classe precisa implementar a interface Iterable se desejar ter um loop for-each para iterar sua coleção. No entanto, o loop for-each pode ser usado apenas para percorrer a coleção na direção direta e você não poderá modificar os elementos nessa coleção . Mas, se tudo o que você deseja é ler os dados dos elementos, é muito simples e, graças à expressão Java lambda, geralmente é um liner. Por exemplo:

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

Iterador

Essa interface permite iterar sobre uma coleção, obtendo e removendo seus elementos. Cada uma das classes de coleção fornece um método iterator () que retorna um iterador para o início da coleção. A vantagem dessa interface em relação ao iterável é que, com essa interface, você pode adicionar, modificar ou remover elementos em uma coleção . Mas, acessar elementos precisa de um pouco mais de código do que iterável. Por exemplo:

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

Fontes:

1. Java Doc Iterable
2. Java Doc Iterator

Iterable foram introduzidos para uso em cada loop em java

public interface Collection<E> extends Iterable<E>  

Iteratoré uma classe que gerencia a iteração sobre um Iterable. Ele mantém um estado de onde estamos na iteração atual e sabe qual é o próximo elemento e como obtê-lo.