Array Iterators arrays in Java do not implement the Iterable

interface; hence, arrays do not supply iterators

if you implement a class that uses an array to hold a collection of objects and you want to provide an iterator for the collection, you need to implement your own iterator class

suppose we have a class X that has an array of Y objects

1

public class X implements Iterable<Y>

{

private Y[] yArray;

// default constructor; creates yArray with

// length 0

public X()

{

this(0);

}

2

// constructor; creates yArray with

// length numberOfY

public X(int numberOfY)

{

if(numberOfY < 0)

throw IllegalArgumentException("negative

numberOfY");

this.yArray = new Y[numberOfY];

}

// …

3

YIterator because X implements Iterable, we must

supply a method named iterator that supplies an iterator to a Y object

we will call the class that defines the iterator to a Y object YIterator

4

import java.util.Iterator;

import java.util.NoSuchElementException;

class YIterator implements Iterator<Y>

{

// attributes and constructors coming up...

// Returns true if the iteration has more

// elements.

public boolean hasNext()

{ // ... }

5

// Returns the next element in the iteration.

public Y next()

{ // ... }

// Removes from the underlying collection the last

// element returned by the iterator (optional

// operation).

public void remove()

{ // ... }

}

6

Attributes how does a YIterator

know if there are more elements? return an element?

YIterator needs an attribute that holds the reference or a copy of

the array it is iterating over an attribute that allows the iterator to return the

next element recall that array elements are indexed using an integer

between 0 and (array length – 1)

7

Version 1: Reference to array class YIterator implements Iterator<Y>

{

private Y[] yArray;

private int nextIndex;

// precondition: arrayOfY not null

public YIterator(Y[] arrayOfY)

{

this.yArray = arrayOfY;

this.nextIndex = 0;

}

8

Version 2: Copy of array class YIterator implements Iterator<Y>

{

private Y[] yArray;

private int nextIndex;

// precondition: arrayOfY not null

public Yiterator(Y[] arrayOfY)

{

this.yArray = Arrays.copyOf(arrayOfY,

arrayOfY.length);

this.nextIndex = 0;

}

9

hasNext hasNext returns true if

the array yArray has an element at index nextIndex and

the element at index nextIndex is not null recall that every array has a public attribute

called length that gives the number of elements in the array the array yArray has an element at index nextIndex only if nextIndex < yArray.length

10

0 1 2 3 4

yArray yArray.length == 5

if nextIndex > 4 yArray[nextIndex] throwsArrayIndexOurOfBoundsException

Array Memory Diagram for Objects

11

500 Y[] object

length 5

yArray[0]

yArray[1]

yArray[2]

yArray[3]

yArrat[4]

references to objects of type Y

Y[] yArray = new Y[5];for(int i = 0; i < yArray.length; ++i) yArray[i] = new Y();

null

null

null

null

null

1600

1500

1400

1300

1200

Array Memory Diagram for Objects

12

500 fArray object

length 5

fArray[0]

fArray[1]

fArray[2]

fArray[3]

fArrat[4]

instances of type int

float[] fArray = new float[5];for(int i = 0; i < yArray.length; ++i) fArray[i] = (float)i;

0

0

0

0

0

4f

3f

2f

1f

0f

// verbose version

public boolean hasNext()

{

boolean result = false;

if(this.nextIndex < this.yArray.length &&

this.yArray[nextIndex] != null)

{

result = true;

}

return result;

}

13

// compact version

public boolean hasNext()

{

return this.nextIndex < this.yArray.length &&

this.yArray[nextIndex] != null;

}

14

if hasNext returns true then the client can call next to get the next element in the iteration if hasNext returns false and the client calls next a NoSuchElementException is thrown

the next method needs to1. check that hasNext is true; if not an exception is

thrown2. get the element at index nextIndex from the array

yArray3. move nextIndex to the next element in the array

(increment)

15

// verbose version public Y next() { if(this.hasNext()) { Y nextY = this.yArray[this.nextIndex]; this.nextIndex++; return nextY; } else { throw new NoSuchElementException("no more elements"); } }

16

// compact version public Y next() { if(this.hasNext()) { return this.yArray[this.nextIndex++]; } else { throw new NoSuchElementException("no more elements"); } }

17

remove remove is an optional operation

removes from the underlying collection the last element returned by the iterator the client must first call the next method (to return an

element) and then call remove not as easy as removing the element indexed by nextIndex

if the iterator does not support remove it must throw an UnsupportedOperationException

18

public void remove()

{

throw new

UnsupportedOperationException("Iterator does

not support remove");

}

19

Removing an Element from an Array removing an element from an array should

reduce the length of the array by 1 Java does not support resizable arrays

need to create a new array that is missing the removed element

20

500 Y[] object

length 5

1200

1300

remove 1400

1500

1600

2000 Y[] object

length 4

1200

1300

1500

1600

A Question suppose your iterator class supports remove

and copies the array it is iterating over (slide 9) what problem do you need to address when

implementing remove?

21