LinkedList & Array mplementation

Question

I am coding a program and i have an interface for a doubly linked list. Below are 2 parts which r giving me problems.
(1) The array-based implementation:
The implementation should be robust in that the list grows until an OutOfMemory error occurs. I did a small part of itL:
public class DoublyLinkedListImpl implements SimpleLinkedList {
public DoublyLinkedListImpl() {
     array_impl = new Object[size];
private void resize() {
Object[ ] temp = new Object[array_impl.length * 2]; // double the size
     //*** copy array_impl stuff to temp: see java.utils.Arrays for help
array_impl = temp;
private static final int size = 8; //*** initial size and resize amount
private Object[ ] array_impl;
The add methods could call resize as needed. This hides the implementation details from the user.
As the implementation of an ADT, this implementation should exposes to the user only (a) constructors and (b) the public methods specified in the interface.
(2) a test program: This tests the implementation & tries to break the implementation by trying to fetch the non-existent predecessor or successor of a node.
A brief idea of this part:
// The implementing class should provide
// -- a no-arg constructor to construct an empty list
// -- a 1-arg constructor to construct a list with one Object
// -- a 1-arg constructor to construct a list from an Object[ ]
// The implementing class must not
// -- extend a class that implements java.util.List
// -- have fields of a class type that implements java.util.List
// The standard classes that implement java.util.List are
// AbstractList ArrayList LinkedList Vector
// In short, the underlying implementation should be array based.
public abstract interface SimpleLinkedList {
// check whether empty: true if so, false otherwise
public abstract boolean isEmpty();
// get the current node's predecessor, if any: null if none
public abstract Object getPredecessor();
// get the current node's successor, if any: null if none
public abstract Object getSuccessor();
// remove 1st item: true if so, false otherwise
public abstract boolean remove(Object obj);
// remove Nth item: true if so, false otherwise
// remaining items shifted as appropriate
public abstract boolean remove(int n);
// remove all: two signatures, same semantics
public abstract void remove();
public abstract void clear();
// get Nth item: null returned in case of failure
public abstract Object getNth(int n);
// add an item at the end
public abstract void add(Object obj);
// add an item at a specified position: false if bad position
// If the position is bad, item is added to the end.
// Current items are shifted as appropriate.
public abstract boolean add(Object obj, int position);
// return the list as an array (perhaps empty) of Objects
// Changing the returned Object array should not
// change the SimpleLinkedList from which the array was derived.
public abstract Object[ ] toArray();
// traverse the list, printing to the standard output
// the toString value of every Object therein
public abstract void traverse();
}

Answer 1

I think this is what you need (I always only increase or decrease the size by 1, so no resize-method is needed).
public class DoublyLinkedListImpl implements SimpleLinkedList
  private Object[ ] array;
  protected int pos = -1; // current position of "window" on List
  // position -1 means that the array/list is isEmpty
  public DoublyLinkedListImpl()
    array = null;
  public DoublyLinkedListImpl(Object obj)
    add(obj);
  public DoublyLinkedListImpl(Object[] obj_array)
    array = new Object[obj_array.length];
    System.arraycopy(obj_array, 0, array, 0, obj_array.length);
    pos = 0;
  // check whether empty: true if so, false otherwise
  public boolean isEmpty()
    if (pos == -1 || array == null) return true;
    return false;
  // get the current node's predecessor, if any: null if none
  public Object getPredecessor()
    if (pos==0) return null;
    return array[--pos];
  // get the current node's successor, if any: null if none
  public Object getSuccessor()
    if (pos == array.length-1) return null;
    return array[++pos];
  // remove 1st item: true if so, false otherwise
  public boolean remove(Object obj)
    if (isEmpty()) return false;
    if (array.length==1) clear();
    Object[ ] temp = array;
    array = new Object[array.length - 1];
    System.arraycopy(temp, 1, array, 0, array.length);
    return true;
  // remove Nth item: true if so, false otherwise
  // remaining items shifted as appropriate
  public boolean remove(int n)
    if (n==0) { remove(null); return true; }
    if (n<0 || n>array.length-1) return false;
    if (pos>=n) --pos;
    Object[ ] temp = array;
    array = new Object[array.length - 1];
    System.arraycopy(temp, 0, array, 0, n);
    if (n==array.length) return true;
    System.arraycopy(temp, n+1, array, n, array.length-n);
    return true;
  // remove all: two signatures, same semantics
  public void remove()
    array = null;
    pos = -1;
  public void clear()
    remove();
  // get Nth item: null returned in case of failure
  public Object getNth(int n)
    if (isEmpty() || n<0 || n>array.length-1) return null;
    pos = n;
    return array[n];
  // add an item at the end
  public void add(Object obj)
    if (isEmpty())
      array = new Object[1];
      array[0] = obj;
      pos = 0;
      return;
    // resize
    Object[ ] temp = array;
    array = new Object[array.length + 1];
    System.arraycopy(temp, 0, array, 0, temp.length);
    // add
    array[array.length-1] = obj;
    pos = array.length-1;
  // add an item at a specified position: false if bad position
  // If the position is bad, item is added to the end.
  // Current items are shifted as appropriate.
  public boolean add(Object obj, int position)
    if (position<0 || position>array.length-1) { add(obj); return false; }
    pos=position;
    // resize
    Object[ ] temp = array;
    array = new Object[array.length + 1];
    System.arraycopy(temp, 0, array, 0, position);
    array[position] = obj;
    System.arraycopy(temp, position, array, position+1, temp.length-position);
    return true;
  // return the list as an array (perhaps empty) of Objects
  // Changing the returned Object array should not
  // change the SimpleLinkedList from which the array was derived.
  public Object[ ] toArray()
    if (isEmpty()) return null;
    return (Object[]) array.clone();
  // traverse the list, printing to the standard output
  // the toString value of every Object therein
  public void traverse()
    if (isEmpty()) System.out.println("null");
    else for (int i=0; i<array.length; ++i) System.out.println(array);
// for testing purposes only
public static void main(String[] args)
Integer a = new Integer(3), b = new Integer(4), c = new Integer(5);
DoublyLinkedListImpl dlli = new DoublyLinkedListImpl();
System.out.println("Position: "+dlli.pos);
dlli = new DoublyLinkedListImpl(b);
dlli.traverse();
System.out.println("Position: "+dlli.pos);
dlli.add(c);
dlli.traverse();
System.out.println("Position: "+dlli.pos);
dlli.add(a);
dlli.traverse();
System.out.println("Position: "+dlli.pos);
dlli.remove(1);
dlli.traverse();
System.out.println("Position: "+dlli.pos);
dlli.remove(null);
dlli.traverse();
System.out.println("Position: "+dlli.pos);
dlli.clear();
dlli.traverse();
System.out.println("Position: "+dlli.pos);
dlli.add(b);
dlli.traverse();
System.out.println("Position: "+dlli.pos);
dlli.add(a, 0);
dlli.traverse();
System.out.println("Position: "+dlli.pos);
System.out.println("#1: "+dlli.getNth(1));
System.out.println("Position: "+dlli.pos);
System.out.println(dlli.getPredecessor());
System.out.println("Position: "+dlli.pos);
System.out.println(dlli.getPredecessor());
System.out.println("Position: "+dlli.pos);
System.out.println(dlli.getSuccessor());
System.out.println("Position: "+dlli.pos);
System.out.println(dlli.getSuccessor());
System.out.println("Position: "+dlli.pos);
} Monika.