Suppose we wanted to write generic code to return the elements of a list
as a string.  Such code could look like (inside the AbstractList class):

public String toString() {
  String s="";
  for(int i=0;i<size();i++)
    s+=get(i)+" ";
  return s;
}

The problem is that get(i) is fast for an ArrayList but slow for a 
LinkedList.  The frustrating thing is that get(99) does almost all the
work that get(100) needs, but none of the work is reused.  An iterator
solves the problem by remembering the state of where the iterator just was
to figure out what's next.  The code using an iterator would look like:

public String toString() {
  String s="";
  Iterator it=iterator();
  while(it.hasNext()) 
    s+=i.next()+" ";
  return s;
}

Let's look at another method, contains.  contains returns true if the 
arguemnt is found inside the list, false otherwise.  Iterators help here 
too.

public boolean contains(Object o) {
  Iterator it=iterator();
  while(it.hasNext())
    if (it.next().equals(o)) return true;
  return false;
}

An important distinction here is to see if o is *equivalent* to it.next().
The equals method, part of the Object class and usually overridden in 
derived classes, computes the notion of equivalence.

Recall that in Java, variables are either primitives (int, boolean, etc.)
or references to objects.

a = "foo";
b = a;
c = "fo";
c = c+"o";

Here, a==b because they point to the same object.  a!=c because they 
point to different objects.  But a.equals(c) because the objects have 
equivalent contents.

Implementing the equals method for an object will allow the object to be 
used to its fullest extent in lists.  As we learn more, we will also 
implement compareTo and hashCode for objects so they can be used in sorted
or hashed maps or sets.

The equals method says that if the argument is null or of the wrong type,
it returns false (rather than throw an exception).  Then if this and the 
argument are equivalent, return true, false otherwise.

Let's write equals for the List class.  Two lists are equivalent if each 
of their elements in sequence are equivalent.

public boolean equals(Object other) {
  if (!(other instanceof List)) return false; // this checks null too
  if (size()!=other.size()) return false; // quick fail if diff lengths
  Iterator it1=iterator();
  Iterator it2=((List)other).iterator();
  while(it1.hasNext()) 
    if (!(it1.next().equals(it2.next())) return false;
  return true;
}