What does it mean to return an iterator? Java

Question

I have to write a class that implements the Iterable interface. I'm confused about what it means to return an iterator object. An iterator just goes through the elements of a list, so how would I return this as an object? Would I return a list that was able to be iterated through or what? How can an iterator be an object when all it does is go through or change data in other objects?

Answer 1

Here is an example of a very simplistic list. It represents the list as linked elements. The iterator object is created as an anonymous inner class holding the current element as the state. Each call of iterator() creates a new iterator object.

import java.util.Iterator;

public class SimplisticList<T> implements Iterable<T> {

  /*
   * A list element encapsulates a data value and a reference to the next
   * element.
   */
  private static class Element<T> {
    private T data;
    private Element<T> next;

    Element(T data) {
      this.data = data;
      next = null;
    }

    public T getData() {
      return data;
    }

    public Element<T> getNext() {
      return next;
    }

    public void setNext(Element<T> next) {
      this.next = next;
    }

  }

  // We only need a reference to the head of the list.
  private Element<T> first = null;

  // The list is empty if there is no first element.
  public boolean isEmpty() {
    return first == null;
  }

  // Adding a new list element.
  // For an empty list we only have to set the head.
  // Otherwise we have to find the last element to add the new element.
  public void add(T data) {
    if(isEmpty()) {
      first = new Element<T>(data);
    } else {
      Element<T> current = first;
      while(current.getNext() != null) {
        current = current.getNext();
      }
      current.setNext(new Element<T>(data));
    }
  }

  @Override
  public Iterator<T> iterator() {
    // Create an anonymous implementation of Iterator<T>.
    // We need to store the current list element and initialize it with the
    // head of the list.
    // We don't implement the remove() method here. 
    return new Iterator<T>() {
      private Element<T> current = first;

      @Override
      public boolean hasNext() {
        return current != null;
      }

      @Override
      public T next() {
        T result = null;
        if(current != null) {
          result = current.getData();
          current = current.getNext();
        }
        return result;
      }

      @Override
      public void remove() {
        // To be done ...
        throw new UnsupportedOperationException();
      }
    };
  }

}

Answer 2

Returing an iterator means returning an instance of a class that implements the Iterator interface. This class has to implement hasNext(),next() and remove(). The constructor of the class should initialize the instance in a way that next() would return the first element of the data structure you are iterating over (if it's not empty).