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

Je suis nouveau en Java et je suis vraiment confus avec l’iterator et l’itérable. Quelqu’un peut-il m’expliquer et donner des exemples?

Un Iterable est une représentation simple d’une série d’éléments pouvant être itérés. Il n’a pas d’état d’itération tel qu’un “élément actuel”. Au lieu de cela, il a une méthode qui produit un Iterator .

Un Iterator est l’object avec un état d’itération. Il vous permet de vérifier s’il contient 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 Iterable devrait être capable de produire un nombre Iterator valables.

Une implémentation de Iterable est celle qui fournit un Iterator de lui-même:

 public interface Iterable { Iterator iterator(); } 

Un iterator est un moyen simple de permettre à certains de parcourir une collection de données sans privilèges d’atsortingbution (bien qu’avec la possibilité de les supprimer).

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

Voir Javadoc .

Iterable: une interface qui peut être itérée sur C’est-à-dire, qui a la notion de “me faire la première chose, maintenant la prochaine chose, et ainsi de suite, jusqu’à ce que nous soyons à court”.

Iterator: une interface qui gère l’itération sur une itération. C’est-à-dire qu’il garde la trace de notre position dans l’itération actuelle et sait quel est l’élément suivant et comment l’obtenir.

Pour rendre un object itérable, il doit émettre un object Iterator . Pour appliquer ce contrat, l’interface Iterable doit être utilisée. Il contient une méthode nommée iterator () et il renvoie Iterator. Par conséquent, toute classe qui implémente Iterable renverra un iterator.

 public interface Collection extends Iterable {} 

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émentent Collection et cetera.

Un des avantages de Iterable est que lorsque vous implémentez Iterable, ces objects prennent en charge pour: chaque syntaxe de boucle.

Si une collection est itérable, elle peut être itérée à l’aide d’un iterator (et peut donc être utilisée dans un pour chaque boucle). L’iterator est l’object réel qui parcourra la collection.

L’implémentation de l’interface Iterable permet à un object d’être la cible de l’instruction “foreach”.

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

Iterator est une interface qui a une implémentation pour itérer les éléments. Iterable est une interface qui fournit un iterator.

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

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

  1. L’interface itérative force ses sous-classes à implémenter la méthode abstraite «iterator ()».
 public interface Iterable { ... abstract Iterator iterator(); //Returns an 'Iterator'(not iterator) over elements of type T. ... } 
  1. L’interface d’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 les implémentations Collection et Collection 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.

  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 ()’ retourne un object de classe ‘Itr’ qui implémente ‘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. 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(Ssortingng[] 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()) { Ssortingng ssortingng = iterator.next(); System.out.println(ssortingng); } } 

Maintenant, est-ce clair? 🙂

Fondamentalement, les deux sont très proches les uns des autres.

Considérons Iterator comme une interface qui nous aide à parcourir une collection à l’aide de 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 constitue 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 iterator.

Pour plus de compréhension, visitez ces sites:

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

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 iterator qui peut être utilisé pour naviguer.

En mettant en œuvre un iterator, on peut obtenir n’importe quelle pomme, pomme dans les cases suivantes, etc.

Ainsi, l’implémentation itérable donne un iterator pour naviguer dans ses éléments Bien que pour naviguer, l’iterator doit être implémenté.

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

Iterator est une classe qui gère l’itération sur une itération. Il maintient l’état de l’itération actuelle et sait quel est l’élément suivant et comment l’obtenir.

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

iterable: il est lié à forEach loop
iterator: est lié à la collection

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

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

Ne contient qu’un seul iterator de méthode ()
Contient trois méthodes hasNext (), next (), remove ()

Introduit en version 1.5
Introduit dans la version 1.2

En plus des réponses ColinD et Seeker .

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

Iterable

Une classe doit implémenter l’interface Iterable si elle veut avoir une boucle for-each pour parcourir 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, c’est lire les données sur les éléments, alors c’est très simple et grâce à l’expression lambda de Java, il y a souvent une ligne. Par exemple:

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

Itérateur

Cette interface vous permet de parcourir une collection, d’obtenir et de supprimer ses éléments. Chacune des classes de collection fournit une méthode iterator () qui renvoie un iterator au début de la collection. L’avantage de cette interface est que cette interface vous permet d’append, de modifier ou de supprimer des éléments dans une collection . Mais l’access aux éléments nécessite un peu plus de code que d’itération. 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 de document Java