Iterators

1. Iterators CS 367 – Introduction to Data Structures

2. Iterator • Allows a user to step through each item in a data structure • array, vector, linked list, tree, etc. • Two basic components • hasNext() • returns true if the iterator has any more items • next() • returns the next item in the iterator

3. Example • Print out each item in a vector Vector v = new Vector(); addItems(v); Iterator it = v.iterator(); while(it.hasNext()) System.out.println(it.next().toString());

4. Iterator hasNext() == true next hasNext() == true next hasNext() == false next

5. Warning • Note that the next pointer is out-of-bounds after the last call to next() • another call to next() will result in exception • Should always call hasNext() before calling next()

6. Implementation • Three main ways to implement an iterator • single class for an iterator • requires all data structures to implement an iterator specific interface • create a separate, custom iterator class for each data structure • create a custom iterator class for each data structure and make it an inner class inside the appropriate data structure

7. Single Iterator Class • Implement a single class called Iterator • Force each data structure that allows iterators to implement an iterator interface interface DSIterator { public int size(); public Object getIndex(int index);

8. Iterator Class class Iterator { private DSIterator ds; private int nextItem; public Iterator(DSIterator ds) { this.ds = ds; nextItem = 0; } public boolean hasNext() { return nextItem < ds.size(); } public Object next() { Object obj = ds.getIndex(nextItem); nextItem++; return obj; } }

9. Questions • What happens if user calls next() at end of data? • How many times can user to through iterator? • How does user go through the data again?

10. Notes on Single Iterator Class • Advantages • only have to write the iterator class once • Disadvantage • performance can suffer greatly for some data structures

11. Linked List Example class LinkedList implements DSIterator { // start of normal linked list code . . . // end of normal linked list code private int size; // increment (decrement) in add (delete) methods public int size() { return size; } public Object getIndex(int index) { Object tmp = head; for(int i=0; i<index; i++, tmp = tmp.next); return tmp; }

12. Linked List Example • Notice the problem with the getIndex() method • O(n) performance • Want our iterator to return the next item in O(1) time • Will need a different implementation of the iterator for a list than for a vector

13. Custom Class • Previous example shows the need for custom iterator classes for different data structures • Custom class will: • take data structure object through constructor • set a pointer to the first data item • define next() method that works in O(1) time

14. Linked List Implementation class LLIterator { private Node nextItem; public LLIterator(LinkedList list) { nextItem = list.head; } public boolean hasNext() { return nextItem != null; } public Object next() { Object obj = nextItem.data; nextItem = nextItem.next; return obj; } }

15. Notes on Custom Iterator Classes • Advantage • very good performance • next() is always O(1) • Disadvantage • head of Linked List must be made public • this is a bad thing – why? • have to write a custom iterator for each data type • means the user must know which one to use for which data type

16. Nested Iterator Class • Java allows one class to be nested inside another • Nest class has full access to private data of main class • can now let iterator access head • head is still kept as a private field

17. Full Example • Another version of the linked list interface Iterator { public boolean hasNext(); public Object next(); }

18. class LinkedList { private Node head; // put all the usual stuff here public class LLIterator implements Iterator { private Node nextObject; public LLIterator() { nextObject = head; } } public Iterator iterator() { return new Iterator(); } }

19. Notes on Nested Class • Advantage • get the same performance as custom class • it still is a custom class • encapsulation remains in tact • head gets to stay private • Disadvantage • custom iterator for each data structure • a bit more confusing to learn and understand

20. Using Iterators • Assume a nested iterator class public void printContents(Object ds) { Iterator it = ds.iterator(); while(it.hasNext()) System.out.println(it.next().toString()); } • The above code will work with any data structure • of course, it assumes the data structure class supports iterators