1

FOR USERS, THE LinkedCollection and ArrayList classes

Contain An ITERATOR CLASS.

Iterators & the Collection Classes

2

» The Collection Framework classes provided in the JAVA API(Application Programmer Interface) many type of collections like an ArrayList

» These classes implements the List interface

3

There are 35 methods in the Collections Interface.

Several of the methods have to do with the iterator interface.

4

»A key operation of a Collections class is the necessity to traverse and process the data stored in the collection

»Therefore, most Collection classes e.g the ArrayList class, implement a special Interface that provides for this –

»the Iterator interface.

5

» In order to step through a collection in the past we used loops.

» The question is : How can any Collection class allow users to loop through say an ArrayList without making sure they do not corrupt the data?

» The solution is the use of iterators.

6

Iterator

An iterator is an object that enables a user to loop through a collection.

7

» So associated with each class that implements the Collections interface there is an Iterator class.

» Each iterator class must implement the iterator interface which consists of methods that we will examine.

8

The following methods are listed in the iterator interface;

public interface iterator {

T next();

boolean hasnext();

void remove() throws unsupportedException()}

9

public interface Iterator { // Precondition: this Iterator is positioned at

// an element in the Collection. //Postcondition: the element where this //Iterator was positioned at has been //returned, and this Iterator has been //incremented.

T next( );

10

// Postcondition: true is returned if

// this Iterator is positioned at an element //in the Collection. Otherwise, false is // returned.

boolean hasNext( );

11

// Postcondition: No longer supported – throws // an exception void remove( ) throws Unsupported Exception() } // interface Iterator

12

The ArrayList class ( and others) have a nested class that implements the Iterator interface

The nested class - The nested class - ArrayIterator implements the iterator interface..

Let’s look at the code:Let’s look at the code:

13

import java.util.Iterator; import java.util.Iterator; // using the iterator in java. util// using the iterator in java. util

public class ArrayList<T> implements ListADT<T> public class ArrayList<T> implements ListADT<T> { protected final int DEFAULT_CAPACITY = 100; private final int NOT_FOUND = -1; protected int rear; protected T[] list; protected T[] list; //----------------------------------------------------------------- // Creates an empty list using the default capacity. //----------------------------------------------------------------- public ArrayList()public ArrayList() { { rear = 0; rear = 0; list = list = (T[])(new Object[DEFAULT_CAPACITY]);(T[])(new Object[DEFAULT_CAPACITY]); } }

14

//----------------------------------------------------------------- // otherother Methods add and remove etc.Methods add and remove etc. //----------------------------------------------------------------- public T removeFirst() throws EmptyCollectionException { } // OTHER ARRAYLIST METHODS HERE// OTHER ARRAYLIST METHODS HERE //----------------------------------------------------------------- // Returns an iterator for the elements currently in this list. //----------------------------------------------------------------- public ArrayIterator<T> iterator()public ArrayIterator<T> iterator() { return new ArrayIterator<Tnew ArrayIterator<T> (list,list, rearrear); } Note that we pass rear Note that we pass rear ((rear -rear - stores the index of the last item in the array) stores the index of the last item in the array)

And And list list which is the array of T holding the datawhich is the array of T holding the data } }

15

16

8 20 30 60 90 89 34

currentcurrent COUNT

17

8 20 30 60 90 89 34

currentcurrent COUNT

18

19

Look at this code in the ArrayList class:Look at this code in the ArrayList class:// Pre: // Pre: sents references to the arraylist objectsents references to the arraylist object‘”‘”list” and the number of itemslist” and the number of items// Postcondition// Postcondition: an iterator to traverse the arraylist has been returned the main class: an iterator to traverse the arraylist has been returned the main class public Iterator iterator( )

{ return new ArrayInterator(list, count ); } // method iterator This method creates an object of the inner iterator class ArrayInterator( );This method creates an object of the inner iterator class ArrayInterator( ); and returns it to the main applicationand returns it to the main application

20

USER CANNOT DO THIS from an outside class:

Arrayiterator itr = new Array Iterator( );

WHY NOT???

21

The Array Iterator class is an inner class and therefore has

private visibility: inaccessible

outside of the ArrayList class. The only class that can access private inner class ArrayIterator is the ArrayList class

22

THE SOLUTION: A NEW METHOD IN THE ArrayList CLASS:

23

public Iterator iterator( ) { return new ArrayInterator(list, count ); } // method iterator

 

Inside the ArrayList class, we have a method to Inside the ArrayList class, we have a method to create the array iterator create the array iterator

It is called in DatingService when find button is pressed:It is called in DatingService when find button is pressed: “ “List” is the variable for the arraylist of ClientsList” is the variable for the arraylist of Clients

if (e.getActionCommand().equals("FIND"))if (e.getActionCommand().equals("FIND")) { { // code to get an iterator // code to get an iterator ArrayIterator<Client> iter = List.iterator(); ArrayIterator<Client> iter = List.iterator();

24

» For the Linked List class, the nested iterator class –

» class ListIterator class - will have one field:

ListNode<T> cur; // used to traverse list

25

class LinkedIterator<T> implements Iterator { private int count; // the number of elements in the collection private LinearNode<T> curr; // the current position //------------------------------------------------------------- // Sets up this iterator using the specified items.

// first will be equal to head, size is # of items currently in list //-------------------------------------------------------------

public LinkedIterator (LinearNode<T> first , int size) { curr = first; // where first is head points to first node count = size; }

26

// method hasNext returns true as long as//next is not null - allows the iteration over//the collection to continue if there are more//items to process

public boolean hasNext() { return cur != null;}

27

// This method extracts the data from the node and /then advances next to the next node. public T next( ) { // throw an exception if no more items T element = cur.data; // get the data // advances next to the next node cur= cur.getNext(); return element; // returns the data } // method next

28

public class LinkedList { // LinkedList methods listed here //nested Iterator class below

private class LinkedIterator { // methods: next(), hasNext(), remove() } // close inner class LinkedIterator

} // class LinkedList

29

raydoe me null

headData next

cur

Variable to traverse the list

Pointer to next node in the list

30

raydoe me null

head

cur

Data next

Cur traverses the list

31

RETURNED: “ray” – as an Object

32

USER CANNOT DO THIS from an outside class:

Linkedterator itr = new LinkedIterator( );

WHY NOT???

33

The LinkedIterator class is an inner class and therefore has

private visibility: inaccessible

outside of the LinkedList class. The only class that can access private inner class LinkedIterator is the LinkedList class

34

THE SOLUTION: A NEW METHOD IN THE LinkedList CLASS:

35

// Postcondition: a LinkedList over this LinkedCollection has been returned. public Iterator iterator( ) { return new LinkedInterator(head,count ); } // method iterator This method creates an object of the inner iterator class

LinkedInterator( ); and returns it to the main application

36

WHAT IS RETURNED?

A REFERENCE TO AN OBJECT of the LinkedIterator inner Class nested INSIDE THE LinkedList CLASS

class LinkedIterator implements Iterator private int count; // the number of elements in the collection private LinearNode<T> cur; // the current position

public LinkedIterator(LinerarNode<T> first, size ) { cur = first; // sets up cut to point to the beginning of the list – first count -= size; } // constructor//************************************************************* // Precondition: this Iterator is positioned at an element in this Linked Collection. // Postcondition: The element this Iterator was (before this call) positioned at has been //returned, and this Iterator has advanced.//************************************************************* public T next() { T element = cur.data; // get the data cur = cur.getNext(); // advance to the next node return element; // return the element } // method next//************************************************************* // Postcondition: true has been returned if this Iterator is positioned // an element in this Collection. Otherwise, false has been returned.//************************************************************* public boolean hasNext() { return cur != null; // determines if there are more items to processs } // method hasNext//*************************************************************public void remove() { throws unsupported Exception

39

» There is also a ListIterator interface which extends Iterator. The description is at this link:

» http://www.janeg.ca/scjp/util/iterator.html

» It is in java.util and has more methods than the parent interface Iterator

40

» Interface ListIterator, which allows a programmer to traverse a List in either direction and make modifications to the underlying List

» -- Newer versions of the iterator:

41

» Some additional methods in ListIterator:

» hasPrevious() returns true if there are more elements in a backward direction

» previous() returns the previous element in the List

» previousIndex() returns the index of the previous element in the list.

43

» New with JDK 1.5 is the Iterable interface.It resides in java.lang and has some enhancements

» What are the differences between the two (class that implements Iterable and a class that implements Iterator)?

» We can make an iterable object have different kinds of iterators?

44

» class IterableIterator<T> implements Iterable<T>» { » private Iterator<T> iter;

» public IterableIterator(Iterator<T> iter)» { this.iter = iter; }

» public Iterator<T> iterator() » { return iter; » }

» }» Allows different types of iterators to be created

45

class Tree // creates two iterators { IterableIterator<Node>depthFirstIterator(); IterableIterator<Node>breadthFirstIterator(); }

46

» But then, how does this work when we use the iterable object in a foreach statement?

» How do we specfify which iterator we want to use?

» for (Node node: aTree.depthFirstIterator()){}

47

» And by the way, the only benefit of the previous example is to be able to use a for loop on an iterable collection.

» You can just use a while loop when you want to use a different traversal method from the default one, and provide a second iterator() method.

48

» In addition, for now the Iterable interface is not backward compatible.