In This Project, Especially To Test The Int NextIndex() And

In This Project, Especially To Test The Int NextIndex() And Int PreviousIntex() Methods, My Client Class Is Like This BelowIn this project, especially to test the int nextIndex() and int previousIntex() methods,

my client class is like this below:

The output with testing int nextIndex() and int previousIntex() methods is like this below

Can anybody help my code count the index value in the backward or forward direction??

Here is my entire code except client class (I already posted the client class above)

Those are the ArrayList and ArrayListIterator class.

ArrayList.java

==========================

package arraylist;

import java.util.Arrays;
import java.util.Iterator;

public class ArrayList {

public ArrayList() {
this(DEFAULT_CAPACITY);
}

@SuppressWarnings(“unchecked”)
public ArrayList(int capacity) {
if (capacity < 0) {
throw new IllegalArgumentException(“capacity: ” + capacity);
}
elementData = (E[]) new Object[capacity];
size = 0;
}

public int size() {
return size;
}

public E get(int index) {
checkIndex(index);
return elementData[index];
}

public String toString() {
if(size ==0) {
return “[]”;
}
else {
String result = “[” + elementData[0];
for(int i =1;iresult += “, ” +elementData[i];
}
result +=”]”;
return result;
}
}

public int indexOf(E value) {
for(int i=0;iif(elementData[i].equals(value)) {
return i;
}
}
return -1;
}

public boolean isEmpty() {
return size ==0;
}

public boolean contains(E value) {
return indexOf(value) >=0;
}

public boolean containsAll(ArrayList list) {
for(int i=0;iif(!contains(list.elementData[i])) {
return false;
}
}
return true;
}

public void add(E value) {
ensureCapacity(size + 1);
elementData[size] = value;
size++;
}

public void add(int index, E value) {
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException(“index: ” + index);
}
ensureCapacity(size + 1); //this public method throws the exception
for(int i = size; i>=index+1; i–) {
elementData[i] = elementData[i-1];
}
elementData[index] = value;
size++;
}

public void addAll(int index, ArrayList list) {
ensureCapacity(list.size+1);
for(int i=0; iadd(index,list.elementData[i]);
index++;
}
}

public void remove(int index) {
checkIndex(index);
for(int i = index; ielementData[i] = elementData[i+1];
}
elementData[size-1]=null;
size–;
}

public void removeAll(ArrayList list) {
for(int i=0; iint index = indexOf(list.elementData[i]);
if(index>0)
remove(index);
}
}

public void set(int index, E value) {
checkIndex(index);
elementData[index] = value;
}

public void clear() {
for(int i=0; ielementData[i] = null;
}
size = 0;
}

public void addAll(ArrayList other) {
ensureCapacity(size + other.size);
for(int i=0; iadd(other.elementData[i]);
}
}

public Iterator iterator(){
return new ArrayListIterator2(this);
}

public void ensureCapacity(int capacity) {
if (capacity > elementData.length) {
int newCapacity = elementData.length * 2 + 1;
if (capacity > newCapacity) {
newCapacity = capacity; }
elementData = Arrays.copyOf(elementData, newCapacity);
}
}

public void checkIndex(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException(“index: ” + index);
}
}

}

=================================

ArrayListIterator2.java

=================================

package arraylist;

import java.util.Iterator;
import java.util.NoSuchElementException;

public class ArrayListIterator2 implements Iterator {
private int position;
private boolean removeOK;
private ArrayList list; // create a instance of array list class

// Returns the next element in the list and advances the position
public E next() {
if(!hasNext()) {
throw new NoSuchElementException();
}
E result = list.get(position);
position++;
removeOK = true;
return result;
}

// Returns true if this list iterator has more elements when traversing the list in the reverse direction
public boolean hasPrevious() {
return position > 0;
}

// Removes from the list the last element that was returned by next() or previous()
public void remove() {
if(!removeOK) {
throw new IllegalStateException();
}
position–;
list.remove(position);
removeOK = false;
}

// Replaces the last element returned by next() or previous() with the specified element
public void set(E value) {
if(!removeOK) {
throw new IllegalStateException();
}
list.set(position, value);
}
}