Qual è la differenza tra iteratore e iterabile e come usarli?

Sono nuovo in Java e sono davvero confuso con iteratore e iterabile. Qualcuno può spiegarmi e fare alcuni esempi?

An Iterableè una semplice rappresentazione di una serie di elementi che possono essere ripetuti. Non ha alcuno stato di iterazione come un "elemento corrente". Invece, ha un metodo che produce un Iterator.

An Iteratorè l'oggetto con stato di iterazione. Ti permette di verificare se ha più elementi usando hasNext()e passa all'elemento successivo (se presente) usando next().

In genere, Iterabledovrebbe essere in grado di produrre un numero qualsiasi di messaggi validi Iterator.

Un'implementazione di Iterableè quella che fornisce una Iteratordi se stessa:

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

Un iteratore è un modo semplice per consentire ad alcuni di passare in rassegna una raccolta di dati senza privilegi di assegnazione (anche se con possibilità di rimozione).

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

Vedi Javadoc .

Risponderò alla domanda soprattutto su ArrayList come esempio per aiutarti a capire meglio ..

1. L'interfaccia Iterable impone alle sue sottoclassi di implementare il metodo astratto 'iteratore ()'.

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

2. L'interfaccia di Iterator impone alle sue sottoclassi di implementare il metodo astratto 'hasNext ()' e '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 implementa List, List estende Collection e Collection estende Iterable .. Cioè, potresti vedere la relazione come

   'Iterable <- Collection <- List <- ArrayList'

. E Iterable, Collection ed List dichiarano semplicemente il metodo astratto 'iterator ()' e solo ArrayList lo implementa.

4. Mostrerò il codice sorgente di ArrayList con il metodo 'iterator ()' come segue per informazioni più dettagliate.

Il metodo 'iterator ()' restituisce un oggetto della classe 'Itr' che implementa '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. Alcuni altri metodi o classi eseguiranno l'iterazione di elementi di raccolte come ArrayList mediante l'utilizzo di Iterator (Itr).

Qui c'è un semplice esempio.

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);
    }
}

Adesso è chiaro? :)

Se una raccolta è iterabile, può essere iterata usando un iteratore (e di conseguenza può essere usata in un per ogni ciclo.) L'iteratore è l'oggetto reale che itererà attraverso la raccolta.

L'implementazione dell'interfaccia Iterable consente a un oggetto di essere la destinazione dell'istruzione "foreach".

class SomeClass implements Iterable<String> {}

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

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

Iterator è un'interfaccia, che ha un'implementazione per iterare su elementi. Iterable è un'interfaccia che fornisce Iterator.

La considerazione più importante è se l'oggetto in questione debba essere attraversato più di una volta. Questo perché puoi sempre riavvolgere un Iterable chiamando nuovamente iterator (), ma non c'è modo di riavvolgere un Iterator.

Come spiegato qui , " Iterable " è stato introdotto per poter essere utilizzato nel foreachloop. Una classe che implementa l' interfaccia Iterable può essere ripetuta.

Iterator è una classe che gestisce l'iterazione su un Iterable . Mantiene uno stato di dove siamo nell'iterazione corrente e sa qual è l'elemento successivo e come ottenerlo.

Considera un esempio con 10 mele. Quando implementa Iterable, è come mettere ogni mela in scatole da 1 a 10 e restituire un iteratore che può essere usato per navigare.

Implementando iteratore, possiamo ottenere qualsiasi mela, mela nelle prossime caselle ecc.

Pertanto, l'implementazione di iterabile fornisce a un iteratore di navigare i suoi elementi sebbene, per navigare, l'iteratore debba essere implementato.

Domanda: differenza tra Iterable e Iterator?
Ans:

iterabile: è correlato a forEach loop
iteratore: è correlato a Collection

L'elemento target del loop forEach può essere iterabile.
Possiamo usare Iterator per ottenere l'oggetto uno alla volta dalla Collezione

Iterabile presente nel pacchetto java.ḷang
Iteratore presente nel pacchetto java.util

Contiene solo un metodo iteratore ()
Contiene tre metodi hasNext (), next (), remove ()

Introdotto nella versione 1.5
Introdotto nella versione 1.2

Fondamentalmente, entrambi sono strettamente collegati tra loro.

Considera Iterator come un'interfaccia che ci aiuta a attraversare una raccolta con l'aiuto di alcuni metodi indefiniti come hasNext (), next () e remove ()

D' altro canto , Iterable è un'altra interfaccia, che, se implementata da una classe, forza la classe ad essere Iterable ed è un obiettivo per il costrutto For-Each. Ha solo un metodo chiamato iterator () che proviene dalla stessa interfaccia Iterator.

Quando una raccolta è iterabile, può essere iterata usando un iteratore.

Per capire visita questi:

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

So che questa è una vecchia domanda, ma per chiunque legga questo che è bloccato con la stessa domanda e che può essere sopraffatto da tutta la terminologia, ecco una buona e semplice analogia per aiutarti a capire questa distinzione tra iterabili e iteratori:

Pensa a una biblioteca pubblica. Vecchia scuola. Con i libri di carta. Sì, quel tipo di biblioteca.

Uno scaffale pieno di libri sarebbe come un iterabile. Puoi vedere la lunga fila di libri sullo scaffale. Potresti non sapere quanti, ma puoi vedere che è una lunga raccolta di libri.

Il bibliotecario sarebbe come l'iteratore. Può indicare un libro specifico in qualsiasi momento. Può inserire / rimuovere / modificare / leggere il libro in quella posizione in cui sta indicando. Indica, in sequenza, ogni libro alla volta ogni volta che urli "prossimo!" a lui. Quindi, normalmente gli chiederesti: "ha Next?", E lui dirà "sì", al quale tu dirai "prossimo!" e indicherà il prossimo libro. Sa anche quando ha raggiunto la fine dello scaffale, quindi quando chiedi: "ha Next?" dirà "no".

So che è un po 'sciocco, ma spero che questo aiuti.

Oltre alle risposte di ColinD e Seeker .

In termini semplici, Iterable e Iterator sono entrambe le interfacce fornite in Java Framework Collection.

iterable

Una classe deve implementare l'interfaccia Iterable se vuole avere un ciclo for-each per scorrere la propria raccolta. Tuttavia, il ciclo for-each può essere utilizzato solo per scorrere la raccolta in avanti e non sarà possibile modificare gli elementi in questa raccolta . Ma, se tutto ciò che vuoi è leggere i dati degli elementi, allora è molto semplice e grazie all'espressione lambda Java è spesso una riga. Per esempio:

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

Iterator

Questa interfaccia consente di scorrere su una raccolta, ottenendo e rimuovendo i suoi elementi. Ciascuna delle classi di raccolta fornisce un metodo iteratore () che restituisce un iteratore all'inizio della raccolta. Il vantaggio di questa interfaccia su iterabile è che con questa interfaccia è possibile aggiungere, modificare o rimuovere elementi in una raccolta . Tuttavia, l'accesso agli elementi richiede un po 'più di codice di quanto sia iterabile. Per esempio:

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

fonti:

1. Java Doc Iterable
2. Java Doc Iterator

Iterable sono stati introdotti per l'uso in per ogni ciclo in Java

public interface Collection<E> extends Iterable<E>  

Iteratorè una classe che gestisce l'iterazione su un Iterable. Mantiene uno stato di dove siamo nell'iterazione corrente e sa qual è l'elemento successivo e come ottenerlo.