// very similar to the ArrayList class in OpenJDK

.

Modify the SimpleArrayList class to provide the implementation of the missing methods in SimpleArrayListIterator

:

SimpleArrayListIterator

(

int index

)

(the constructor)

boolean

hasNext()

int nextIndex()

boolean hasPrevious()

E previous()

int previousIndex()

The meaning of the methods should be the same as

of

the

corresponding

ones

provided by

the interfac

e

j

ava.util.List

Iterator

.

You

must

check for the concurrent modification error.

Please, consult

the

Java SE API documentation

,

as neede

import java.lang.UnsupportedOperationException;

import java.util.NoSuchElementException;

import java.util.ConcurrentModificationException;

import java.util.Arrays;

import java.util.ListIterator;

/**

* This class provides a simple generic list implmented as

* an array. It is similar to the ArrayList class included

* in the java.util package.

*

* The first element of the list is at position 0 and the

* last element is at position list.size() - 1.

*

* Except for the method next(), implementation of the

* SimpleArrayListIterator methods is left as part of your

* project.

*/

public class SimpleArrayList {

public static final int DEFAULTSZ = 20; // default array size

private Object[] list; // contents of the list

private int count; // number of the list elements

private int modCount = 0; // the total number of modifications

// (add and remove calls)

/**

* Creates an ampty SimpleArrayList with the default capacity

*/

public SimpleArrayList()

{

list = new Object[ DEFAULTSZ ];

count = 0;

}

public boolean isEmpty()

{

return count == 0;

}

public int size()

{

return count;

}

/**

* Adds an element at the end of the list.

* @param e the element to be added to the list.

* @return true always

*/

public boolean add( E e )

{

// make sure that the list has sufficient space

ensureCapacity( count + 1 );

list[ count ] = e;

count++;

modCount++;

return true;

}

/**

* Returns the element of the list at the indicated position.

* @param index the position of the list element to return.

* @return the element at position index.

* @throws IndexOutOfBoundsException if the index is < 0 or >= the size of the list.

*/

public E get( int index )

{

// check if the given index is valid

if( index < 0 || index >= count )

throw new IndexOutOfBoundsException( "Index value: " + index );

@SuppressWarnings("unchecked")

E e = (E) list[ index ];

return e;

}

/**

* Adds an element to the list at the specified position. It is possible to add

* a new element at the end of the list when index is equal to the size of the list.

* @param index the position where the element should be added.

* @param e the element to be added to the list.

* @return true

* @throws IndexOutOfBoundsException if the index out of range, i.e. index < 0 or index > the size().

*/

public boolean add( int index, E e )

{

// check if the given index is valid

if( index < 0 || index > count )

throw new IndexOutOfBoundsException( "Index value: " + index );

// make sure that the list has sufficient space

ensureCapacity( count + 1 );

// shift the contents of the array one spot to the right from index

System.arraycopy( list, index, list, index + 1, count - index);

list[ index ] = e;

modCount++;

count++;

return true;

}

public E remove( int index )

{

// check if the given index is valid

if( index < 0 || index >= count )

throw new IndexOutOfBoundsException( "Index value: " + index );

// get the element removed

@SuppressWarnings("unchecked")

E removed = (E) list[ index ];

// shift the contents of the array one cell to the left from index, but only if

// it is not the last cell

if( index < count - 1 )

System.arraycopy( list, index+1, list, index, count - index - 1 );

list[ --count ] = null;

modCount++;

return removed;

}

/**

* Returns the index of the first occurrence of a given element on the list equal

* or -1 if the given element is not on the list. If the argument element is null,

* the method returns the index of the first null elment on the list, or -1 if the list

* has no null elements.

* @param e the element to be located on the list.

* @return the index of the first occurrence of a given element on the list equal

* or -1 if the given element is not on the list.

*/

public int indexOf( E e )

{

if( e != null ) {

// look for the first non-null element equal to the argument e

for( int i = 0; i < count; i++ )

if( list[ i ] != null && list[ i ].equals( e ) )

return i;

}

else {

// look for the first null element, since the argument is null

for( int i = 0; i < count; i++ )

if( list[ i ] == null )

return i;

}

return -1;

}

/**

* Returns a ListIterator of the list elements, starting at the given position in this list.

* @param index the position of the first element on the list to be returned from the iterator.

* If the index is equal to the size of the list, the iterator starts at the end of the list.

* @return the created ListIterator

* @throws IndexOutOfBoundsException if the index is < 0 or > the size of the list.

*/

public ListIterator listIterator( int index )

{

if( index < 0 || index > count )

throw new IndexOutOfBoundsException( "Index value: " + index );

return new SimpleArrayListIterator( index );

}

// Make sure that the capacity of the list is large enough to accomodate

// sz number of elements. If not, enlarge the list array by allocating

// a larger array and copying the old content.

private void ensureCapacity( int sz )

{

Object[] newList = null;

// if the list is large enough, return immediately

if( list.length >= sz )

return;

// compute the next larger size, as a multiple of DEFAULTSZ

int newSize = (sz / DEFAULTSZ + 1) * DEFAULTSZ;

// create a new array and copy the old contents into it

list = Arrays.copyOf( list, newSize );

}

/**

* This class provides an iterator for the SimpleArrayList.

* It partially implements the java.util.ListIterator interface.

*

* Except for the method next(), implementation of the

* SimpleArrayListIterator methods is left as part of your

* project.

*/

private class SimpleArrayListIterator

implements ListIterator

{

private int currPos = 0; // index of the element to be returned next

private int expectedModCount = modCount;

// Creates a new iterator starting at position index.

// javadoc comment needed

public SimpleArrayListIterator( int index )

{

// replace with your code

}

// Returns true if this list iterator has more elements when traversing the list forward.

// javadoc comment needed

public boolean hasNext()

{

// replace with your code

return true;

}

// Returns true if this list iterator has more elements when traversing the list in the reverse direction.

// javadoc comment needed

public boolean hasPrevious()

{

// replace with your code

return true;

}

/**

* Returns the next element on the list.

* @return the next element on the list.

* @throw NoSuchElementException if the next element does not exist.

*/

@SuppressWarnings("unchecked")

public E next()

{

checkForComodification();

if( currPos >= count )

throw new NoSuchElementException();

// note the use of the "outer" class reference in SimpleArrayList.this

// to access the outer class

return (E) SimpleArrayList.this.list[ currPos++ ];

}

// Returns the index of the element that would be returned by a call to next.

// javadoc comment needed

public int nextIndex()

{

// replace with your code

return 0;

}

// Returns the previous element in the list.

// javadoc comment needed

@SuppressWarnings("unchecked")

public E previous()

{

// replace with your code

return null;

}

// Returns the index of the element that would be returned by a call to previous.

// javadoc comment needed

public int previousIndex()

{

// replace with your code

return 0;

}

// the following are optional operations which are not supported in the

// SimpleArrayList implementation; no modifications/additions are needed here

// Adds a new element

// not implemented here

public void add(Object e)

{

throw new UnsupportedOperationException( "add is not available" );

}

// Removes from the list the last element that was returned by next or previous (optional operation).

// not implemented here

public void remove()

{

throw new UnsupportedOperationException( "remove is not available" );

}

// Replaces the last element returned by next or previous with the specified element (optional operation).

// not implemented here

public void set(Object e)

{

throw new UnsupportedOperationException( "set is not available" );

}

// check if there was a concurrent modification of the list contents.

// if yes, throw a ConcurrentModificationException exception

private final void checkForComodification() {

if (expectedModCount != SimpleArrayList.this.modCount)

throw new ConcurrentModificationException();

}

}

}

import java.util.ListIterator;

public class DemoSimpleArrayListIter

{

public static void main(String[] args)

{

SimpleArrayList sList = new SimpleArrayList();

SimpleArrayList iList = new SimpleArrayList();

if( sList.isEmpty() )

System.out.println( "sList is empty: no elements: " + sList.size() );

else

System.out.println( "sList is not empty: no elements: " + sList.size() );

System.out.println( "Adding at end: A B C D E F" );

sList.add( "A" );

sList.add( "B" );

sList.add( "C" );

sList.add( "D" );

sList.add( "E" );

sList.add( "F" );

if( sList.isEmpty() )

System.out.println( "sList is empty: no elements: " + sList.size() );

else

System.out.println( "sList is not empty: no elements: " + sList.size() );

ListIterator iter = sList.listIterator( 0 );

System.out.print( "List: {" );

while( iter.hasNext() )

System.out.print( " " + iter.next() );

System.out.println( " }" );

System.out.print( "List in reverse: {" );

while( iter.hasPrevious() )

System.out.print( " " + iter.previous() );

System.out.println( " }" );

for( int i = 0; i < 110; i++ )

iList.add( i );

ListIterator iter2 = iList.listIterator( 0 );

System.out.print( "List: {" );

while( iter2.hasNext() )

System.out.print( " " + iter2.next() );

System.out.println( " }" );

if( iter.hasNext() )

System.out.println( "Step to the next: " + iter.next() );

if( iter.hasNext() )

System.out.println( "Step to the next: " + iter.next() );

// add an element

sList.remove( 3 );

if( sList.isEmpty() )

System.out.println( "sList is empty: no elements: " + sList.size() );

else

System.out.println( "sList is not empty: no elements: " + sList.size() );

if( iter.hasNext() )

System.out.println( "Step to the next: " + iter.next() );

}

}