Pourquoi l' Iteratorinterface ne s'étend pasIterable ?

La iterator()méthode pourrait simplement retourner this.

Est-ce intentionnel ou simplement une erreur des concepteurs de Java?

Il serait pratique de pouvoir utiliser une boucle for-each avec des itérateurs comme ceci:

for(Object o : someContainer.listSomeObjects()) {
    ....
}

où listSomeObjects()renvoie un itérateur.

Parce qu'un itérateur pointe généralement vers une seule instance dans une collection. Iterable implique que l'on peut obtenir un itérateur à partir d'un objet pour traverser ses éléments - et il n'est pas nécessaire d'itérer sur une seule instance, ce que représente un itérateur.

Un itérateur est avec état. L'idée est que si vous appelez Iterable.iterator()deux fois, vous obtiendrez des itérateurs indépendants - du moins pour la plupart des itérables. Ce ne serait clairement pas le cas dans votre scénario.

Par exemple, je peux généralement écrire:

public void iterateOver(Iterable<String> strings)
{
    for (String x : strings)
    {
         System.out.println(x);
    }
    for (String x : strings)
    {
         System.out.println(x);
    }
}

Cela devrait imprimer la collection deux fois - mais avec votre schéma, la deuxième boucle se terminerait toujours instantanément.

Pour mon 0,02 $, je suis tout à fait d'accord pour dire qu'Iterator ne devrait pas implémenter Iterable, mais je pense que la boucle for améliorée devrait non plus accepter. Je pense que tout l'argument «rendre les itérateurs itérables» apparaît comme une solution à un défaut de langage.

La seule raison de l'introduction de la boucle for améliorée était qu'elle "élimine la corvée et la propension aux erreurs des itérateurs et des variables d'index lors de l'itération sur des collections et des tableaux" [ 1 ].

Collection<Item> items...

for (Iterator<Item> iter = items.iterator(); iter.hasNext(); ) {
    Item item = iter.next();
    ...
}

for (Item item : items) {
    ...
}

Pourquoi alors ce même argument ne vaut-il pas pour les itérateurs?

Iterator<Iter> iter...
..
while (iter.hasNext()) {
    Item item = iter.next();
    ...
}

for (Item item : iter) {
    ...
}

Dans les deux cas, les appels à hasNext () et next () ont été supprimés et il n'y a aucune référence à l'itérateur dans la boucle interne. Oui, je comprends que les Iterables peuvent être réutilisés pour créer plusieurs itérateurs, mais que tout se passe en dehors de la boucle for: à l'intérieur de la boucle, il n'y a jamais de progression vers l'avant, un élément à la fois, sur les éléments retournés par l'itérateur.

En outre, autoriser cela faciliterait également l'utilisation de la boucle for pour les énumérations, qui, comme cela a été souligné ailleurs, sont analogues aux itérateurs et non aux itérables.

Donc, ne laissez pas Iterator implémenter Iterable, mais mettez à jour la boucle for pour accepter non plus.

À votre santé,

Comme l'ont souligné d'autres, Iteratoret ce Iterablesont deux choses différentes.

De plus, les Iteratorimplémentations sont antérieures aux boucles for améliorées.

Il est également trivial de surmonter cette limitation avec une méthode d'adaptateur simple qui ressemble à ceci lorsqu'elle est utilisée avec des importations de méthode statique:

for (String line : in(lines)) {
  System.out.println(line);
}

Exemple d'implémentation:

  /**
   * Adapts an {@link Iterator} to an {@link Iterable} for use in enhanced for
   * loops. If {@link Iterable#iterator()} is invoked more than once, an
   * {@link IllegalStateException} is thrown.
   */
  public static <T> Iterable<T> in(final Iterator<T> iterator) {
    assert iterator != null;
    class SingleUseIterable implements Iterable<T> {
      private boolean used = false;

      @Override
      public Iterator<T> iterator() {
        if (used) {
          throw new IllegalStateException("SingleUseIterable already invoked");
        }
        used = true;
        return iterator;
      }
    }
    return new SingleUseIterable();
  }

Dans Java 8, adapter un Iteratorà unIterable devient plus simple:

for (String s : (Iterable<String>) () -> iterator) {

Comme d'autres l'ont dit, un Iterable peut être appelé plusieurs fois, renvoyant un nouvel Iterator à chaque appel; un itérateur n'est utilisé qu'une seule fois. Ils sont donc liés, mais servent des objectifs différents. Malheureusement, la méthode «compact pour» ne fonctionne qu'avec un itérable.

Ce que je décrirai ci-dessous est une façon d'avoir le meilleur des deux mondes - renvoyer un Iterable (pour une syntaxe plus agréable) même lorsque la séquence de données sous-jacente est unique.

L'astuce consiste à renvoyer une implémentation anonyme de l'itérable qui déclenche réellement le travail. Ainsi, au lieu de faire le travail qui génère une séquence ponctuelle puis de renvoyer un Iterator dessus, vous retournez un Iterable qui, chaque fois qu'il est accédé, refait le travail. Cela peut sembler un gaspillage, mais souvent vous n'appelerez l'itérable qu'une seule fois de toute façon, et même si vous l'appelez plusieurs fois, il a toujours une sémantique raisonnable (contrairement à un simple wrapper qui fait qu'un Iterator "ressemble" à un Iterable, cela a gagné ' t échouer s'il est utilisé deux fois).

Par exemple, disons que j'ai un DAO qui fournit une série d'objets à partir d'une base de données, et que je veux donner accès à cela via un itérateur (par exemple pour éviter de créer tous les objets en mémoire s'ils ne sont pas nécessaires). Maintenant, je pourrais simplement retourner un itérateur, mais cela rend l'utilisation de la valeur retournée dans une boucle moche. Donc, à la place, j'emballe tout dans un Iterable anon:

class MetricDao {
    ...
    /**
     * @return All known metrics.
     */
    public final Iterable<Metric> loadAll() {
        return new Iterable<Metric>() {
            @Override
            public Iterator<Metric> iterator() {
                return sessionFactory.getCurrentSession()
                        .createQuery("from Metric as metric")
                        .iterate();
            }
        };
    }
}

cela peut ensuite être utilisé dans un code comme celui-ci:

class DaoUser {
    private MetricDao dao;
    for (Metric existing : dao.loadAll()) {
        // do stuff here...
    }
}

ce qui me permet d'utiliser la boucle for compacte tout en conservant l'utilisation de la mémoire incrémentielle.

Cette approche est «paresseuse» - le travail n'est pas fait lorsque l'itérable est demandé, mais seulement plus tard lorsque le contenu est répété - et vous devez être conscient des conséquences de cela. Dans l'exemple avec un DAO, cela signifie itérer sur les résultats dans la transaction de base de données.

Il y a donc plusieurs mises en garde, mais cela peut encore être un idiome utile dans de nombreux cas.

Incroyablement, personne d'autre n'a encore donné cette réponse. Voici comment vous pouvez "facilement" parcourir un Iteratoren utilisant la nouvelle Iterator.forEachRemaining()méthode Java 8 :

Iterator<String> it = ...
it.forEachRemaining(System.out::println);

Bien sûr, il existe une solution "plus simple" qui fonctionne directement avec la boucle foreach, enveloppant le Iteratordans un Iterablelambda:

for (String s : (Iterable<String>) () -> it)
    System.out.println(s);

Iteratorest une interface qui vous permet de parcourir quelque chose. C'est une implémentation de se déplacer dans une collection quelconque.

Iterable est une interface fonctionnelle qui indique que quelque chose contient un itérateur accessible.

En Java8, cela vous facilite la vie ... Si vous avez un Iteratormais que vous en avez besoin, Iterablevous pouvez simplement faire:

Iterator<T> someIterator;
Iterable<T> = ()->someIterator;

Cela fonctionne également dans la boucle for:

for (T item : ()->someIterator){
    //doSomething with item
}

Je suis d'accord avec la réponse acceptée, mais je veux ajouter ma propre explication.

• L'itérateur représente l'état de la traversée, par exemple, vous pouvez obtenir l'élément courant d'un itérateur et passer au suivant.

• Iterable représente une collection qui pourrait être parcourue, il peut renvoyer autant d'itérateurs que vous le souhaitez, chacun représentant son propre état de parcours, un itérateur peut pointer vers le premier élément, tandis qu'un autre peut pointer vers le 3ème élément.

Ce serait bien si Java for loop accepte à la fois Iterator et Iterable.

Pour éviter de dépendre du java.utilpackage

Selon le JSR original, une boucle for améliorée pour le langage de programmation Java ™ , les interfaces proposées:

• java.lang.Iterable
• java.lang.ReadOnlyIterator
  (proposé d'être modernisé java.util.Iterator, mais apparemment cela ne s'est jamais produit)

… Ont été conçus pour utiliser l' java.langespace de noms du package plutôt que java.util.

Pour citer le JSR:

Ces nouvelles interfaces servent à empêcher la dépendance du langage sur java.util qui en résulterait autrement.

À propos, l'ancien a java.util.Iterableacquis une nouvelle forEachméthode en Java 8+, à utiliser avec la syntaxe lambda (en passant a Consumer).

Voici un exemple. L' Listinterface étend l' Iterableinterface, car toute liste porte une forEachméthode.

List
.of ( "dog" , "cat" , "bird" )
.forEach ( ( String animal ) -> System.out.println ( "animal = " + animal ) );

J'en vois aussi beaucoup faire ceci:

public Iterator iterator() {
    return this;
}

Mais cela ne règle pas les choses! Cette méthode ne serait pas ce que vous voulez!

La méthode iterator()est censée renvoyer un nouvel itérateur à partir de zéro. Il faut donc faire quelque chose comme ça:

public class IterableIterator implements Iterator, Iterable {

  //Constructor
  IterableIterator(SomeType initdata)
  {
    this.initdata = iter.initdata;
  }
  // methods of Iterable

  public Iterator iterator() {
    return new IterableIterator(this.intidata);
  }

  // methods of Iterator

  public boolean hasNext() {
    // ...
  }

  public Object next() {
    // ...
  }

  public void remove() {
    // ...
  }
}

La question est: y aurait-il un moyen de faire en sorte qu'une classe abstraite exécute cela? Donc, pour obtenir un IterableIterator, il suffit d'implémenter les deux méthodes next () et hasNext ()

Si vous êtes venu ici à la recherche d'une solution de contournement, vous pouvez utiliser IteratorIterable . (disponible pour Java 1.6 et supérieur)

Exemple d'utilisation (inverser un vecteur).

import java.util.Vector;
import org.apache.commons.collections4.iterators.IteratorIterable;
import org.apache.commons.collections4.iterators.ReverseListIterator;
public class Test {
    public static void main(String ... args) {
        Vector<String> vs = new Vector<String>();
        vs.add("one");
        vs.add("two");
        for ( String s: vs ) {
            System.out.println(s);
        }
        Iterable<String> is
            = new IteratorIterable(new ReverseListIterator(vs));
        for ( String s: is ) {
            System.out.println(s);
        }
    }
}

impressions

one
two
two
one

Par souci de simplicité, Iterator et Iterable sont deux concepts distincts, Iterable est simplement un raccourci pour «Je peux renvoyer un Iterator». Je pense que votre code devrait être:

for(Object o : someContainer) {
}

avec someContainer instanceof SomeContainer extends Iterable<Object>

En passant: Scala a une méthode toIterable () dans Iterator. Voir la conversion implicite ou explicite de scala d'itérateur en itérable

Sur une note connexe, vous pouvez trouver l'adaptateur IteratorIterable dans Apache Commons Collections4 utile. Créez simplement une instance à partir d'un itérateur et vous avez l'itérable correspondant.

https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/iterators/IteratorIterable.html

ID: org.apache.commons: commons-collections4: 4.0

Les itérateurs sont avec état, ils ont un élément "suivant" et deviennent "épuisés" une fois itérés. Pour voir où est le problème, exécutez le code suivant, combien de nombres sont imprimés?

Iterator<Integer> iterator = Arrays.asList(1,2,3).iterator();
Iterable<Integer> myIterable = ()->iterator;
for(Integer i : myIterable) System.out.print(i);
System.out.println();
for(Integer i : myIterable) System.out.print(i);

Vous pouvez essayer l'exemple suivant:

List ispresent=new ArrayList();
Iterator iterator=ispresent.iterator();
while(iterator.hasNext())
{
    System.out.println(iterator.next());
}