Quelle est la différence entre iterator et iterable et comment les utiliser?

Je suis nouveau en Java et je suis vraiment confus avec iterator et iterable. Quelqu'un peut-il m'expliquer et donner quelques exemples?

An Iterableest une représentation simple d'une série d'éléments sur lesquels il est possible de répéter. Il n'a aucun état d'itération tel qu'un "élément courant". Au lieu de cela, il a une méthode qui produit un fichier Iterator.

An Iteratorest l'objet avec l'état d'itération. Il vous permet de vérifier s'il a plus d'éléments en utilisant hasNext()et de passer à l'élément suivant (le cas échéant) en utilisant next().

En règle générale, un Iterabledevrait être en mesure de produire n'importe quel nombre de Iterators valides .

Une implémentation de Iterableest celle qui fournit un Iteratorde lui-même:

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

Un itérateur est un moyen simple de permettre à certains de parcourir une collection de données sans privilèges d'attribution (mais avec la possibilité de supprimer).

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

Voir Javadoc .

Je répondrai à la question en particulier sur ArrayList à titre d'exemple afin de vous aider à mieux comprendre.

1. L'interface Iterable force ses sous-classes à implémenter la méthode abstraite 'iterator ()'.

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

2. L'interface Iterator force ses sous-classes à implémenter les méthodes abstraites 'hasNext ()' et '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 implémente la liste, la liste étend la collection et la collection étend Iterable. Autrement dit, vous pouvez voir la relation comme

   'Iterable <- Collection <- Liste <- ArrayList'

. Et Iterable, Collection et List déclarent simplement la méthode abstraite 'iterator ()' et ArrayList seul l'implémente.

4. Je vais montrer le code source ArrayList avec la méthode 'iterator ()' comme suit pour des informations plus détaillées.

La méthode 'iterator ()' renvoie un objet de la classe 'Itr' qui implémente '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. Certaines autres méthodes ou classes itéreront des éléments de collections comme ArrayList en utilisant Iterator (Itr).

Voici un exemple 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);
    }
}

Maintenant, est-ce clair? :)

Si une collection est itérable, alors elle peut être itérée à l'aide d'un itérateur (et par conséquent peut être utilisée dans une pour chaque boucle.) L'itérateur est l'objet réel qui itérera dans la collection.

L'implémentation de l'interface Iterable permet à un objet d'être la cible de l'instruction "foreach".

class SomeClass implements Iterable<String> {}

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

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

Iterator est une interface qui a une implémentation pour itérer sur des éléments. Iterable est une interface qui fournit Iterator.

La considération la plus importante est de savoir si l'élément en question doit pouvoir être parcouru plus d'une fois. C'est parce que vous pouvez toujours rembobiner un Iterable en appelant à nouveau iterator (), mais il n'y a aucun moyen de rembobiner un Iterator.

Comme expliqué ici , le « Iterable » a été introduit pour pouvoir être utilisé dans la foreachboucle. Une classe implémentant l' interface Iterable peut être itérée.

Iterator est une classe qui gère l'itération sur un Iterable . Il maintient un état où nous en sommes dans l'itération actuelle, et sait quel est l'élément suivant et comment l'obtenir.

Prenons un exemple avec 10 pommes. Quand il implémente Iterable, c'est comme mettre chaque pomme dans des cases de 1 à 10 et retourner un itérateur qui peut être utilisé pour naviguer.

En implémentant l'itérateur, nous pouvons obtenir n'importe quelle pomme, pomme dans les boîtes suivantes, etc.

Ainsi, l'implémentation de iterable donne à un itérateur la possibilité de naviguer dans ses éléments, mais pour naviguer, l'itérateur doit être implémenté.

Question: Différence entre Iterable et Iterator?
Ans:

iterable: il est lié à l'
itérateur de boucle forEach : Is est lié à la collection

L'élément cible de la boucle forEach doit être itérable.
Nous pouvons utiliser Iterator pour obtenir l'objet un par un de la collection

Iterable présent dans le package java.ḷang
Iterator présent dans le package java.util

Contient une seule méthode iterator ()
Contient trois méthodes hasNext (), next (), remove ()

Introduit dans la version 1.5
Introduit dans la version 1.2

Fondamentalement, les deux sont très étroitement liés les uns aux autres.

Considérez Iterator comme une interface qui nous aide à parcourir une collection à l'aide de certaines méthodes non définies comme hasNext (), next () et remove ()

D'un autre côté, Iterable est une autre interface qui, si elle est implémentée par une classe, force la classe à être Iterable et est une cible pour la construction For-Each. Il n'a qu'une seule méthode nommée iterator () qui provient de l'interface Iterator elle-même.

Lorsqu'une collection est itérable, elle peut être itérée à l'aide d'un itérateur.

Pour comprendre, visitez ces:

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

Je sais que c'est une vieille question, mais pour quiconque lit ceci qui est coincé avec la même question et qui peut être submergé par toute la terminologie, voici une bonne analogie simple pour vous aider à comprendre cette distinction entre les itérables et les itérateurs:

Pensez à une bibliothèque publique. Vieille école. Avec des livres en papier. Oui, ce genre de bibliothèque.

Une étagère pleine de livres serait comme un itérable. Vous pouvez voir la longue file de livres dans l'étagère. Vous ne savez peut-être pas combien, mais vous pouvez voir qu'il s'agit d'une longue collection de livres.

Le bibliothécaire serait comme l'itérateur. Il peut pointer vers un livre spécifique à tout moment. Il peut insérer / supprimer / modifier / lire le livre à l'endroit où il pointe. Il pointe, dans l'ordre, chaque livre à la fois chaque fois que vous criez "suivant!" à lui. Donc, vous lui demanderiez normalement: "a le suivant?", Et il dira "oui", auquel vous répondez "suivant!" et il indiquera le prochain livre. Il sait également quand il a atteint le bout de l'étagère, de sorte que lorsque vous demandez: "a Next?" il dira "non".

Je sais que c'est un peu idiot, mais j'espère que cela aide.

En plus des réponses ColinD et Seeker .

En termes simples, Iterable et Iterator sont tous deux des interfaces fournies dans Collection Framework de Java.

Itérable

Une classe doit implémenter l'interface Iterable si elle veut avoir une boucle for-each pour itérer sur sa collection. Cependant, la boucle for-each ne peut être utilisée que pour parcourir la collection dans le sens direct et vous ne pourrez pas modifier les éléments de cette collection . Mais, si tout ce que vous voulez est de lire les données des éléments, c'est très simple et grâce à l'expression Java lambda, c'est souvent une ligne. Par exemple:

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

Itérateur

Cette interface vous permet d'itérer sur une collection, d'obtenir et de supprimer ses éléments. Chacune des classes de collection fournit une méthode iterator () qui renvoie un itérateur au début de la collection. L'avantage de cette interface par rapport aux itérations est qu'avec cette interface, vous pouvez ajouter, modifier ou supprimer des éléments dans une collection . Mais, accéder aux éléments nécessite un peu plus de code que d'itérables. Par exemple:

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

Sources:

1. Java Doc Iterable
2. Itérateur Java Doc

Iterable ont été introduits pour utiliser dans pour chaque boucle en java

public interface Collection<E> extends Iterable<E>  

Iteratorest une classe qui gère l'itération sur un fichier Iterable. Il maintient un état où nous en sommes dans l'itération actuelle, et sait quel est l'élément suivant et comment l'obtenir.