Doubly linked

public class ObjectList<T> {

    private Node firstNode;
    private Node currentNode;
    private Node lastNode;
    private int numberOfEntries;

    public T getCurrent() {
        T result = currentNode.data;
        return result;
    }

    public T getFirst(){
        if (numberOfEntries == 0) {
            return null;
        }
        while(currentNode.previous != null)  {
            currentNode = currentNode.previous;
        }
        firstNode = currentNode;
        T result = firstNode.data;
        return result;
    }

    public T getNext() {
        if (numberOfEntries == 0){
            return null;
        }
        if (currentNode.next == null){
            return currentNode.data;
        }
        else{
            T next = currentNode.next.data;
            return next;
        }
    }

    public T getPrevious(){
        if (numberOfEntries == 0){
            return null;
        }
        if (currentNode.previous == null){
            return currentNode.data;
        }
        else{
            T prev = currentNode.previous.data;
            return prev;
        }
    }

    public T getLast(){
        if (numberOfEntries == 0) {
            return null;
        }
        while(currentNode.next != null) {
            currentNode = currentNode.next;
        }
        lastNode = currentNode;
        T result = lastNode.data;
        return result;
    }

    //boolean append(T newObject);

    boolean insert(T newObject){
        //Create new node
        Node newNode = new Node(newObject);

        //If list is empty
        if (numberOfEntries == 0) {
            firstNode = newNode;
            lastNode = newNode;
            currentNode = newNode;
        }

        //Reassign previous and next of current node to new node
        newNode.previous = currentNode.previous;
        currentNode.previous = newNode;
        newNode.next = currentNode;

        //Change next of new node's previous node
        if (newNode.previous != null){
            newNode.previous.next = newNode;
        }
        //If the previous of new node is null, it will become the new first node
        else {
            firstNode = newNode;
        }

        numberOfEntries++;

        return true;
    }
    //Returns the removed entry if successful, or returns null
    /*
    public T remove(){
    T result = null;
    if (currentNode != null){
    result = currentNode.data;
    Node prevNode = currentNode.previous;
    Node nextNode = currentNode.next;
    //reassign nodes on either side of current to each other
    prevNode
    //Previous value becomes current node

    currentNode = currentNode.previous;
    }
    return result;
    }
     */
    //boolean replace(T newObject);

    /*
    public boolean clear() {

    }

     */
    public int getLength(){
        int length = 0;
        Node currentNode = firstNode;
        while ((length < numberOfEntries) && (currentNode != null)) {
            length++;
            currentNode = currentNode.next;
        }
        return length;
    }

    /** Retrieves all entries that are in this bag.
    @return  A newly allocated array of all the entries in this bag. */
    public T[] toArray(){
        // The cast is safe because the new array contains null entries
        @SuppressWarnings("unchecked")
        T[] result = (T[])new Object[numberOfEntries]; // Unchecked cast

        int index = 0;
        Node currentNode = firstNode;
        while ((index < numberOfEntries) && (currentNode != null)){
            result[index] = currentNode.data;
            index++;
            currentNode = currentNode.next;
        } // end while

        return result;
    } // end toArray

    //int getCurrentPosition();
    private class Node {
        private T    data; // Entry in bag
        private Node next;
        private Node previous;// Link to next node

        private Node(T dataPortion){
            this(dataPortion, null, null);
        } // end constructor

        private Node(T dataPortion, Node nextNode, Node prevNode){
            data = dataPortion;
            next = nextNode;
            previous = prevNode;
        } // end constructor
    }
}