Quelle est la différence entre itérateur et itératif et comment les utiliser?

Une application de Iterable est celui qui fournit un Iterator de 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'affectation (mais avec possibilité de supprimer).

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

Voir Javadoc.

Itérable: Une interface qui peut être itérée. Qui est, celui qui a une notion de "donnez-moi la première chose, maintenant la chose suivante, et ainsi de suite, jusqu'à ce que nous exécuter."

Iterator: Une Interface qui gère l'itération sur un itérable. C'est, il garde une trace de l'endroit où nous sommes dans l'itération en cours, et sait ce que l'élément suivant et comment l'obtenir.

Pour faire un objet itérable il doit émettre un Iterator objet. Pour appliquer ce contrat, itérable interface est utilisée. Il contient une méthode nommée iterator() et il renvoie Iterator. Par conséquent, toute classe qui implémente Iterable retournera un itérateur.

public interface Collection<E> extends Iterable<E> {}

Par exemple, prenez N'importe quelle Collection. Une Collection est une interface qui représente un conteneur pour une série d'éléments. Toutes les collections comme ArrayList, Vector implémente Collection et donc Iterator.

Un avantage de Iterable est que lorsque vous implémentez Iterable, ces objets prennent en charge la syntaxe for:each loop.

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

L'implémentation D'une interface itérable 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 les éléments. Iterable est une interface qui fournit Iterator.

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

Je vais répondre à la question en particulier sur ArrayList comme exemple afin de vous aider à mieux comprendre..

1. l'interface itérable 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.
  ...
}

1. l'interface Iterator force ses sous-classes à implémenter la méthode abstraite ' 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.
  ...
}

1. ArrayList implémente List, List implémente Collection et Collection implémente itérable.. C'est, vous pouvez voir la relation comme

   'Itérable

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

1. 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 'Itérateur'.

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

1. 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? :)

Fondamentalement parlant, 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 itérable et est une cible pour chaque construction. Il n'a qu'une seule méthode nommée iterator () qui vient de l'interface itérateur 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:

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

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

Considérons un exemple ayant 10 pommes. Quand il implémente Iterable, c'est comme mettre chaque pomme dans des boîtes de 1 à 10 et retourner un itérateur qui peut être utilisé pour naviguer.

En implémentant iterator, nous pouvons obtenir n'importe quelle Pomme, Pomme dans les boîtes suivantes, etc.

Donc, l'implémentation iterable donne un itérateur pour naviguer dans ses éléments bien que pour naviguer, iterator doit être implémenté..

Comme expliqué ici, le " itérable " a été introduit pour pouvoir être utilisé dans la boucle foreach. Une classe implémentant l'interface itérable peut être itérée.

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

Question: différence entre itérable et itérateur?
Réponse:

Itérable: il est lié à la boucle forEach
iterator: Is est lié à 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

Itérable présent en java.packageang paquet
Itérateur présent en java.util package

Ne Contient qu'une seule méthode iterator()
Contient trois méthodes hasNext (), next(), supprimer()

Introduit dans la version 1.5
Introduit dans la version 1.2

En plus de ColinD et Demandeur d' réponses.

En termes simples, Iterableet Iterator sont les deux interfaces fournies dans le Framework de Collection de Java.

Itérable

Une classe doit implémenter l'interface itérable si elle veut avoir une bouclefor-each pour itérer sur sa collection. Cependant, la boucle for-each ne peut être utilisée que pour faire défiler la collection dans le forward 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, alors c'est très simple et grâce à Java lambda expression c'est souvent un liner. 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 sur itérable est qu'avec cette interface , vous pouvez ajouter, modifier ou supprimer des éléments dans une collection. Mais, l'accès aux éléments nécessite un peu plus de code qu'itérable. 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 Itérable
2. Itérateur Java Doc