Implementation of generic unordered list in java

Question

This question is a follow-up question of this question. These features are added to the new class -

• Generic class
• User is capable of setting the size
• List interface has been added
• Iterator class has been added

As of now I still have some questions after developing this class.

• Does this list interface have enough methods/behavior?
• Why do I have to type cast from next() while returning data?
• When I am testing this class I have to do this Iterator<Integer> itr = ((UnorderedList) ul).iterator(); why?

Thanks to him to open my eyes to design a class to iterate over a structure. My prof of Data Structure even did not specify or taught students important things like this.

If this class is still lacking anything then as always suggestions and advice are appreciated.

//List interface

package lists.arrayLists;
public interface List<T>
{
 boolean isFull();
 boolean isEmpty();
 boolean add(T data);
 void remove(T data);
 boolean find(T data);
 int size();
}

// Unordered List class

package lists.arrayLists.unorderedList;
import lists.arrayLists.List;
import java.lang.IndexOutOfBoundsException;
import java.util.Iterator;
import java.util.NoSuchElementException;
public class UnorderedList<T> implements List<T>, Iterable<T>
{
 private static int MAX_SIZE = 100;
 private int size;
 private Node<T>[] nodeElements;
 public UnorderedList()
 {
 nodeElements = new Node[MAX_SIZE];
 }
 public UnorderedList(int capacity)
 {
 MAX_SIZE = capacity;
 nodeElements = new Node[MAX_SIZE];
 }
 @Override
 public boolean isFull()
 {
 return (size() == MAX_SIZE);
 }
 @Override
 public boolean isEmpty()
 {
 return (size() == 0);
 }
 @Override
 public int size()
 {
 return size;
 }
 @Override
 public boolean add(T data)
 {
 try
 {
 Node<T> node = new Node<>(data);
 nodeElements[size++] = node;
 return true;
 }
 catch (IndexOutOfBoundsException ex)
 {
 System.out.println(ex.getMessage());
 throw new IndexOutOfBoundsException();
 }
 }
 @Override
 public void remove(T data)
 {
 int index = locate(data);
 try
 {
 nodeElements[index] = nodeElements[size() - 1];
 size--;
 }
 catch (IndexOutOfBoundsException ex)
 {
 throw new NoSuchElementException();
 }
 }
 @Override
 public boolean find(T data)
 {
 return (locate(data) >= 0);
 }
 private int locate(T data)
 {
 for (int index = 0; index < size(); index++)
 {
 if (data == nodeElements[index].getData())
 {
 return index;
 }
 }
 return - 1;
 }
 @Override
 public Iterator<T> iterator()
 {
 return new ULIterator<T>();
 }
 private class ULIterator<T> implements Iterator<T>
 {
 private int currentIndex = 0;
 @Override
 public boolean hasNext()
 {
 return (currentIndex < size());
 }
 @Override
 public T next()
 {
 if(hasNext())
 {
 return (T)nodeElements[currentIndex++].getData();
 }
 else
 {
 throw new NoSuchElementException();
 }
 }
 }
}

// Node class

package lists.arrayLists.unorderedList;
public class Node<T>
{
 private T data;
 public Node(T data)
 {
 this.data = data;
 }
 public T getData()
 {
 return data;
 }
}

• Sharon Ben Asher: why not implement java.util.List?

Answer 1

Does this list interface have enough methods/behavior?

Yes, it is enough. If you want to extend it consider implementing java.util.Collection interface.

Why do I have to type cast from next() while returning data?

When I am testing this class I have to do this Iterator itr = ((UnorderedList) ul).iterator(); why?

Those two questions are related. You need a cast to UnorderedList since you didn't put iterator() function in your List interface. And cast for next() is required since you used (UnorderedList) ul instead of (UnorderedList<Integer>) ul.

If MAX_SIZE is a constant it should have final modifier and shouldn't be changed in UnorderedList(int capacity). You might use nodeElements.length instead. Node class looks pointless, there is nothing wrong with using T[] nodeElements or better Object[] nodeElements, since generic arrays are tricky to construct.

You also shouldn't catch IndexOutOfBoundsException when you can just check if index is valid before accessing it.