1. Iterators Chapter 7

2. Chapter Contents What is an Iterator? A Basic Iterator Visits every item in a collection Knows if it has visited all items Doesn’t know what items it has visited. Iterator Methods that Modify the ADT Tricky if “modify” means “change location” Implementing an Internal Iterator Can only be one Implementing an Iterator as Its Own Class Can have many An External Iterator An Inner Class

3. Idea of Iteration How is it different from above? You don’t need to k now about “position” to use it. int listSize = nameList.getLength(); for (int position = 1; position <= listSize; position++) System.out.println(nameList.getEntry(position));

4. What Is an Iterator? A program component Enables you to step through (traverse) a collection of data Can tell whether next entry exists Iterator may be manipulated Asked to advance to next entry Give a reference to current entry Modify the list as you traverse it

5. A Basic Iterator import java.util.NoSuchElementException; public interface BasicIteratorInterface { /** Task: Determines whether the iteration has completed its traversal * and gone beyond the last entry in the collection of data. * @return true if the iteration has another entry to return */ public boolean hasCurrent(); /** Task: Advances the current position of the iteration by 1. * @return true if the iteration has another entry to return */ public boolean advance(); /** Task: Retrieves the current entry in the iteration. * @return a reference to the current entry in the iteration, if one exists * @throws NoSuchElementException, if no current entry exists */ public T getCurrent() throws NoSuchElementException; /** Task: Sets the iteration to begin with the first entry in the collection. */ public void reset(); } // end BasicIteratorInterface Our methods throw exceptions, must import exception from java.util

6. A Basic Iterator Fig. 7-1 The effect of iterator methods on a list.

7. Iterator Methods That Modify the ADT import java.util.NoSuchElementException; public interface IteratorInterface extends BasicIteratorInterface {public boolean hasCurrent(); public boolean advance(); public T getCurrent() throws NoSuchElementException; public void reset(); /** Task: Adds a new entry immediately after the current entry, if one exists. * @param newEntry the object that is the new entry * @throws NoSuchElementException, if no current entry exists */ public void addAfterCurrent(T newEntry) throws NoSuchElementException; /** Task: Removes the current entry, if one exists, and advances the iteration to the next entry. * @throws NoSuchElementException, if no current entry exists */ public void removeCurrent() throws NoSuchElementException; /** Task: Replaces the current entry with a new entry. * @param newEntry the object that replaces the current entry * @throws NoSuchElementException, if no current entry exists */ public void replaceCurrent(T newEntry) throws NoSuchElementException; } // end IteratorInterface

8. Iterator Methods That Modify the ADT Fig. 7-2 The effect of iterator methods on a list.

9. Iterator Methods That Modify the ADT Fig. 7-2 (ctd.) The effect of iterator methods on a list.

10. Implementing an Internal Iterator Including the methods that IteratorInterface specifies import java.util.NoSuchElementException; public class LinkedListWithInternalIterator implements ListInterface, IteratorInterface { private Node firstNode; private int length; private Node currentNode; // current node in iteration private Node priorNode; // node before the current node in iteration // in case you want to remove current public LinkedListWithInternalIterator(){ clear(); } // end default constructor public final void clear() { firstNode = null; length = 0; currentNode = null; priorNode = null; } // end clear } // end LinkedListWithInternalIterator

11. Implementing an Internal Iterator Fig. 7-3 Before and after removing current entry when its node is first in the chain.

12. Implementing an Internal Iterator Fig. 7-4 Before and after removing current entry when its node is not first in the chain.

13. Implementing an Internal Iterator Fig. 7-5 Before and after adding an entry after the current entry.

14. Implementing an Iterator as Its Own Class Fig. 7-6 Counting the number of times that Jane appears in a list of names.

15. Implementing an Iterator as Its Own Class Internal iterator easy to understand, use But only one iteration of a list can occur at any one time May need multiple iterators for a single list Create an external iterator Allows multiple instances of an iterator for a list

16. An External Iterator Fig. 7-7 An external iterator with a reference to an ADT, an indicator of its position within the iteration, and know knowledge of the ADT's implementation

17. An External Iterator An external iterator must access an ADT's data by using public methods of the ADT As a result is slower in performing its operations At the same time its implementation is straightforward Possible to have multiple instances of independent external iterators An iterator for an existing implementation of an ADT that cannot be altered must be an external iterator

18. Inner Class Iterators Have direct access to an ADT's data Thus is as efficient as an internal iterator Has similar implementation effort Advantage Can have several iterator objects in existence at same time Each can traverse list independently of one another

19. Inner Class Iterators Fig. 7-8 An inner class iterator with direct access to the linked chain that implements the ADT.

20. java.util.Iterator package java.util; public interface Iterator { /** Task: Determines whether the iteration has completed its traversal * and gone beyond the last entry in the collection of data. * @return true if the iteration has another entry to return */ public boolean hasNext(); /** Task: Retrieves the current (next) entry in the collection * and advances the iteration by one position. * @return a reference to the current entry in the iteration, * if one exists * @throws NoSuchElementException if the iteration had reached the * end already, that is, if hasNext() is false */ public T next();... } // end Iterator

21. java.util.Iterator /** Task: Removes from the collection of data the last entry * that next() returned. A subsequent call to next() will * behave as it would have before the removal. * Precondition: next() has been called, and remove() has not * been called since then. The collection has not been * altered during the iteration except by calls to this * method. * @throws IllegalStateException if next() has not been called, * or if remove() was called already after the last * call to next(). * @throws UnsupportedOperationException if this iterator does * not permit a remove operation. * NOTE: All throws are run-time so no throws declaration required */ public void remove(); // Optional } // end Iterator

22. Using an Iterator import java.util.* LinkedList ll = new LinkedList(); ll.add(“Andy”); ll.add(“Olga”); ll.add(“Aiko”); Iterator i = ll.iterator(); while ( I.hasNext() ) { String s = i.next(); // process s } for ( Iterator i = ll.iterator(); i.hasNext();) { s = i.next(); // process s }

23. Inner Iterator Class private class IteratorForLinkedList implements Iterator { private Node curr, prev, preprev; private IteratorForLinkedList() { curr = firstNode; prev = preprev = null; } // returns value of curr and then advances curr public T next() { if ( hasNext()) { Node returnNode = curr; if ( curr != firstNode) preprev = prev; prev = curr; curr = curr.next; return returnNode.data; } else { throw new NoSuchElementException("Illegal call to next()"); }

24. Inner Iterator Class (2) public boolean hasNext() { return curr != null; } // Removes from the underlying collection the last element // returned by the iterator; must call next() first. For example, // you can't call next(); remove(); remove(); public void remove() { if ( preprev == prev) return; // next() must be called first else { if ( preprev == null ) { firstNode = curr; length--; prev = null; } else { preprev.next = curr; prev = preprev; length--; }

25. Inner Iterator Class (3) // Now how do we deliver an inner class Iterator to the // rest of the world without exposing its class type (which, // by the way, is unknown to the outside world? // In the ListInterface interface we declare public Iterator getIterator() { return new IteratorForLinkedList(); }