Quelle est la difference 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 des exemples?
Iterable est une représentation simple d’une série d’éléments sur lesquels on peut effectuer une itération. Il n'a aucun état d'itération tel qu'un "élément en cours". Au lieu de cela, il a une méthode qui produit un Iterator.
Iterator est l'objet avec l'état d'itération. Il vous permet de vérifier s’il contient plus d’éléments avec hasNext() et de passer à l’élément suivant (le cas échéant) avec next().
En règle générale, un Iterable devrait pouvoir produire un nombre quelconque de Iterators valides.
Une implémentation de Iterable est une implémentation qui fournit une Iterator:
public interface Iterable<T>
{
Iterator<T> iterator();
}
Un itérateur est un moyen simple d’autoriser certaines personnes à parcourir une collection de données sans privilèges d’attribution (bien qu’il soit possible de les supprimer).
public interface Iterator<E>
{
boolean hasNext();
E next();
void remove();
}
Voir Javadoc .
Si une collection est itérable, elle peut être itérée à l'aide d'un itérateur (et peut donc être utilisée dans une boucle 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.
Je vais répondre à la question en particulier sur ArrayList à titre d'exemple afin de vous aider à mieux comprendre.
- L'interface Iterable oblige 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. ... }
- L'interface Iterator oblige ses sous-classes à appliquer 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. ... }
- ArrayList implémente List, List implémente Collection et Collection implémente Iterable .. Autrement dit, vous pouvez voir la relation comme
'Iterable <- Collection <- List <- ArrayList'
. Et Iterable, Collection et List déclarent simplement la méthode abstraite 'iterator ()' et ArrayList l’applique à elle seule.
- 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 objet de 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]; } ... } }
- 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? :)
La considération la plus importante est de savoir si l’élément en question doit pouvoir être parcouru plus d’une fois. En effet, vous pouvez toujours rembobiner un Iterable en appelant à nouveau iterator (), mais il n’ya aucun moyen de rembobiner un Iterator.
Fondamentalement, les deux sont très liés les uns aux autres.
Considérez Iterator comme une interface qui nous aide à parcourir une collection à l’aide de méthodes non définies telles que 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 constitue une cible pour la construction For-Each . Elle ne comporte qu'une méthode appelée iterator () qui vient 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 sites:
ITERABLE:http://grepcode.com/file/repository.grepcode.com/Java/root/jdk/openjdk/6-b14/Java/lang/Iterable.Java
ITERATORhttp://grepcode.com/file/repository.grepcode.com/Java/root/jdk/openjdk/6-b14/Java/util/Iterator.Java
Comme expliqué ici , “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 un Iterable. Il maintient un état d’avancement de l’itération actuelle et sait quel est le prochain élément et comment l’obtenir.
Prenons un exemple avec 10 pommes . Lorsqu'il implémente Iterable, cela revient à mettre chaque pomme dans des cases allant de 1 à 10 et à renvoyer un itérateur qui peut être utilisé pour naviguer.
En mettant en œuvre iterator, nous pouvons obtenir n'importe quel Apple, Apple dans les cases suivantes, etc.
Donc, implémenter iterable donne à un itérateur la possibilité de naviguer dans ses éléments, bien que pour pouvoir naviguer, cet itérateur soit implémenté.
En plus de ColinD et Seeker answers.
En termes simples, Iterable _ et Iterator_ sont les deux interfaces fournies dans Collection Framework de Java.
Iterable
Une classe doit implémenter l'interface Iterable si elle souhaite disposer d'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 avant 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, c'est très simple et grâce à l'expression Java lambda, c'est souvent un seul support. Par exemple:
iterableElements.forEach (x -> System.out.println(x) );
Iterator
Cette interface vous permet de parcourir une collection, d’obtenir et de supprimer ses éléments. Chacune des classes de la collection fournit une méthode iterator () qui renvoie un itérateur au début de la collection. L'avantage de cette interface par rapport à iterable réside dans le fait qu'avec cette interface vous pouvez ajouter, modifier ou supprimer des éléments d'une collection}. Cependant, l'accès aux éléments nécessite un peu plus de code qu'itable. 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:
Question: Différence entre Iterable et Itérateur?
Ans:
iterable: Il est lié à chaque boucle forEach
iterator: Est-ce lié à Collection
L'élément cible de la boucle forEach doit être itérable.
Nous pouvons utiliser Iterator pour récupérer l’objet un à un dans 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
Iterable ont été introduits pour être utilisés dans chaque boucle en Java
public interface Collection<E> extends Iterable<E>
Iterator est une classe qui gère l'itération sur une Iterable. Il maintient un état d’avancement de l’itération actuelle et sait quel est le prochain élément et comment l’obtenir.