LinkedLIst

/*
 * LinkedList.java
 *
 * @author Lukas Goodman <lukasrossgoodman@gmail.com>
 */

/**
 * Implements a linked list.
 */
public class LinkedList<E> implements List<E> {

/////////////////////////////// FIELDS ///////////////////////////////

    /** Head of this list. */
    private ListNode<E> head;
    /** Size of this list. */
    private int size;

//////////////////////////// CONSTRUCTORS ////////////////////////////

    /**
     * Create a new empty list.
     */
    public LinkedList() {
        clear();
    }

/////////////////////////////// METHODS //////////////////////////////

    /**
     * Make sure n is on [0, n), otherwise throw IndexOutOfBoundsException.
     *
     * @param n number to check
     */
    private void checkN(int n) {
        if (n < 0 || n >= size)
            throw new IndexOutOfBoundsException("" + n);
    }
    private ListNode<E> getFirstNode() {
        return head.getNext();
    }

    private ListNode<E> getNth(int n) {
        checkN(n);
        ListNode<E> node = getFirstNode(); // first node
        for (int i = 0; i < n; i++)
            node = node.getNext();
        return node;
    }

    public boolean add(E e) {
        ListNode<E> added = new ListNode(e);
        ListNode<E> test = getFirstNode();
        if(getFirstNode() == null)
        {
            head.setNext(added);
            size++;
        }
        else
        {
            for(int i = 0; i < size; i++)
            {
                if(test.getNext() == null)
                {
                    break;
                }
                test = test.getNext();

            }
            test.setNext(added);
            size++;
        }
        return true;
    }

    public void clear() {
        head = new ListNode<E>(null);
        size = 0;
    }

    public boolean contains(E e) {
        ListNode<E> test = getFirstNode();
        for(int i = 0; i < size; i++)
        {
            if(test.getValue() == e)
            {
                return true;
            }
            test = test.getNext();
        }
        return false;
    }

    public boolean remove(E e) {
        ListNode<E> test = getFirstNode();
        if(test.getValue().equals(e))
        {
            head.setNext(test.getNext());
            size--;
            return true;
        }
        else
        {
            ListNode<E> temp = getFirstNode();
            for(int i = 0; i < size; i++)
            {

                if(test.getValue().equals(e))
                {
                    temp.setNext(test.getNext());
                    size--;
                    return true;
                }
                temp = test;
                test = test.getNext();
            }
        }
        return false;
    }

    public int size() {
        return size;
    }

    public boolean add(int i, E e) {
        ListNode<E> added = new ListNode(e);
        ListNode<E> test = getFirstNode();
        ListNode<E> temp;
        if(i == 0)
        {
            head.setNext(added);
            added.setNext(test);
            size++;
        }
        else
        {
            for(int k = 0; k < i - 1; k++)
            {
                temp = test.getNext();
                test = temp;
            }
            added.setNext(test.getNext());
            test.setNext(added);
            size++;
        }
        return true;
    }

    public boolean remove(int i) {
        ListNode<E> test = getFirstNode();
        if(i == 0)
        {

            head.setNext(test.getNext());
            size--;
            return true;
        }
        else if(i < size)
        {
            ListNode<E> temp = getFirstNode();
            for(int k = 0; k < i; k++)
            {
                temp = test;
                test = temp.getNext();
            }
            temp.setNext(test.getNext());
            size--;
            return true;
        }
        else
            return false;

    }

    public E get(int i) {
        if(i == 0)
            return getFirstNode().getValue();
        else
        {
            ListNode<E> test = getFirstNode();
            for(int k = 0; k < i; k++)
            {
                test = test.getNext();

            }
            return test.getValue();
        }

    }

    public E set(int i, E e) {  // returns existing element
        ListNode<E> test = getFirstNode();
        ListNode<E> newNode = new ListNode(e);

        if(i == 0)
        {
            head.setNext(newNode);
            newNode.setNext(test.getNext());
            return test.getValue();
        }
        else
        {
            ListNode<E> temp = test;
            for(int k = 0; k < i; k++)
            {
                temp = test;
                test = temp.getNext();

            }
            temp.setNext(newNode);
            newNode.setNext(test.getNext());
            return test.getValue();
        }
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[ ");
        for(ListNode<E> node = getFirstNode(); node != null; node = node.getNext())
            sb.append(node.toString()).append(", ");
        return sb.append("]").toString();
    }
}