GenericLinkedList stringList = new GenericLinkedList();

      stringList.addFirst("C");
      stringList.addFirst("B");
      stringList.addFirst("A");

      // Use our linked list in a for-each loop
      for ( String s : stringList )
          System.out.println(s);

   // Implementing this interface allows an object to be 
   // the target of the "for-each loop" statement. 

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

public class GenericLinkedList<T> implements SimpleList<T>, Iterable<T>
{
   private class Node<T>
   {
      private T item;
      private Node<T> next;

      ...
   }

   private Node<T> first;   // Start of linked list

   public GenericLinkedList()
   {
      first = null;
   }

   ....

   public Iterator<T> iterator() // Implements the Iterable<T> interface 
   {
       // Returns an iterator (object) over elements of type T.
       // We must define a class that returns an Iterator<T> object
   }  
}

   public interface Iterator<T>
   {
       public boolean hasNext(); 
                // Returns true if the iteration has more elements.
 
       public T next(); 
                // Returns the next element in the iteration.
   }

  public class MyLinkedListIterator<T> implements Iterator<T>
  {
      // *** what variables do we need to implement this object ? ***

      public boolean hasNext()
      { 
         // Returns true if the iteration has more elements.
      }
 
      public T next()
      {
          // Returns the next element in the iteration.
      }
  }

   Node current = first;

   while ( current != null ) // Find last list element
   {
       // Process current node here

       current = current.next;  // Move to next node
   }

public class GenericLinkedList<T> implements SimpleList<T>, Iterable<T>
{
   private class Node<T>
   {
      private T item;
      private Node<T> next;

      ...
   }

   private Node<T> first;   // Start of linked list

   public GenericLinkedList()
   {
      first = null;
   }

   ....

   public Iterator<T> iterator() // Implements the Iterable<T> interface 
   {
       // ??? Returns an iterator (object) over elements of type T. Quiz
       // Use MyLinkedListIterator<T> to make an Iterator<T> object
   }  
}

public class GenericLinkedList<T> implements SimpleList<T>, Iterable<T>
{
   private class Node<T>
   {
      private T item;
      private Node<T> next;

      ...
   }

   private Node<T> first;   // Start of linked list

   public GenericLinkedList()
   {
      first = null;
   }

   ....

   public Iterator<T> iterator() // Implements the Iterable<T> interface 
   {
       return new MyLinkedListIterator<T>( first );
       // Use MyLinkedListIterator<T> to make an Iterator<T> object
   }  
}

public class GenericLinkedList<T> implements SimpleList<T>
{
   /*******************************************************
     The private inner class "Node"
    *******************************************************/
   private class Node<T>
   {
      private T item;
      private Node<T> next;

      public Node(T item, Node<T> next)
      {
         this.item = item;
         this.next = next;
      }

      public String toString(){ return "" + this.item; }
   } // End of private inner class "Node"

   ...
}

public class GenericLinkedList<T> implements SimpleList<T>, Iterable<T>
{
   ....
   /*******************************************************
   * Private inner (nested) class MyLinkedListIterator
   * that implements the Java interface "Iterator"
   ********************************************************/
   private class MyLinkedListIterator<T> implements Iterator<T>
   {
       private Node <T> current;  // Current position in the iteration
     
       public MyLinkedListIterator(Node<T> f) // Constructor (every class needs one)
       {
 	   current = f;  // Initialize   
       }
    
       public boolean hasNext() // Returns true if there are more elements.
       { 
 	  return current != null;  // True if there are unvisited nodes 
       }
    
       public T next() // Returns the next element in the iteration.
       {
 	  if ( ! hasNext() )
 	     throw new NoSuchElementException();
    
 	  T res = current.item;    // get item at current position
 	  current = current.next; // move to the next node
 	  return res;
       }
   }
}

   public static void main(String[] args)
   {
      System.out.println("Iterator");

      GenericLinkedList<String> stringList =
                                new GenericLinkedList<String>();

      stringList.addFirst("C");
      stringList.addFirst("B");
      stringList.addFirst("A");
      System.out.println(stringList); // A -> B -> C

      for ( String s : stringList )
          System.out.println(s);
   }

   for ( dataType x : X )  // X is an iterable object
   {
       ...
   }

   Iterator<dataType> helpIter = X.iterator(); 

   while ( helpIter.hasNext() )
   {
       dataType x = helpIter.next();
       ....
   }

   public static void main(String[] args)
   {
      System.out.println("Iterator");

      GenericLinkedList<String> stringList =
                                new GenericLinkedList<String>();

      stringList.addFirst("C");
      stringList.addFirst("B");
      stringList.addFirst("A");
      System.out.println(stringList); // A -> B -> C

      Iterator<String> itr = stringList.iterator();

      while(itr.hasNext())
      {
          System.out.println(itr.next());
      }

   }