Thread: Node List Implementation

I made this to kinda help me understand more of how a LinkedList works. Didn't look at JDK source. Ran out of time so I didn't create Iterator generating methods. Half the shit probably doesn't work to par so yeah

Code:

package impl;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

class NodeList<E> implements List<E> {

    public NodeList() {
        reset();
    }

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

    @Override
    public boolean containsAll(Collection<?> c) {

        Iterator i = c.iterator();
        while(i.hasNext()) {
            if(!contains(i.next())) {
                return false;
            }
        }
        return true;
    }

    @Override
    public boolean contains(Object o) {

        Node<E> current = first;
        for(int i = 0; i < size; i++) {
            if(current.value.equals(o)) {
                return true;
            }
            current = current.next;
        }
        return false;
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        return addAll(0, c);
    }

    @Override
    public boolean addAll(int index, Collection<? extends E> c) {
        int curr = index;
        Iterator i = c.iterator();
        while(i.hasNext()) {
            add(curr++, (E)i.next());
        }
        return true;
    }

    @Override
    public boolean removeAll(Collection<?> c) {

        boolean changed = false;
        Iterator it = c.iterator();
        while (it.hasNext()) {
            if (remove((E) it.next())) {
                changed = true;
            }
        }
        return changed;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        Object[] collection = c.toArray();
        Object[] test = toArray();
        Object[] kept = new Object[c.size()];
        int index = 0;
        for (Object o1 : test) {
            for (Object o2 : collection) {
                if (o2.equals(o1)) {
                    kept[index++] = o1;
                }
            }
        }
        clear();
        for (Object o : kept) {
            add((E) o);
        }
        return true;
    }

    @Override
    public Object[] toArray() {
        Object[] array = new Object[size];
        Node<E> current = first;
        for (int i = 0; i < size; i++) {
            array[i] = (Object) current.value;
            current = current.next;
        }
        return array;
    }

    @Override
    public <T> T[] toArray(T[] type) {
        T[] array = (T[]) new Object[size];
        Node<E> current = first;
        for (int i = 0; i < size; i++) {
            array[i] = (T) current.value;
            current = current.next;
        }
        return array;
    }

    private void reset() {
        first = new Node<E>();
        first.next = first;
    }

    @Override
    public void clear() {
        reset();
    }

    @Override
    public E get(int index) {

        Node<E> current = first;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.value;
    }

    @Override
    public boolean add(E value) {
        if (size >= Integer.MAX_VALUE) {
            return false;
        }

        Node<E> newFirst = new Node<E>();
        newFirst.value = value;
        newFirst.next = first;
        first = newFirst;
        ++size;
        return true;
    }

    @Override
    public E set(int index, E value) {
        if (index > size) {
            throw new IndexOutOfBoundsException("Index > size");
        }

        E old = null;
        Node<E> current = first;
        Node<E> newSlot = new Node<E>();
        for (int i = 0; i < index; i++) {
            if (i == index) {
                newSlot.value = current.value;
                current.value = value;
                newSlot.next = current.next;
                current.next = newSlot;
                return old;
            }
            current = current.next;
        }

        return null;
    }

    @Override
    public void add(int index, E value) {
        set(index, value);
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("Invalid index: " + index);
        }

        Node<E> current = first;
        for (int i = 0; i < size - 1; i++) {
            current = current.next;
        }
        E old = current.next.value;
        current.next = current.next.next;
        --size;
        return old;
    }

    @Override
    public boolean remove(Object value) {
        Node<E> current = first;
        for (int i = 0; i < size; i++) {
            if (current.value.equals(value)) {
                current.value = current.next.value;
                current.next = current.next.next;
                return true;
            }
        }
        return false;
    }

    @Override
    public NodeList<E> subList(int begin, int end) {
        if (begin < 0 || end < 0 || begin > size || end > size || end < begin) {
            throw new IndexOutOfBoundsException("Invalid arguments");
        }

        NodeList<E> sub = new NodeList<E>();
        Node<E> current = first;
        for (int i = 0; i <= end; i++) {

            if (i >= begin) {
                sub.add(current.value);

            }

            current = current.next;
        }
        return sub;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        return null;
    }

    @Override
    public ListIterator<E> listIterator() {
        return null;
    }

    @Override
    public Iterator iterator() {
        return null;
    }

    @Override
    public int lastIndexOf(Object o) {

        int lastIndex = -1;
        Node<E> current = first;
        for (int i = 0; i < size; i++) {
            if (current.value.equals(o)) {
                lastIndex = i;
            }
            current = current.next;
        }
        return lastIndex;
    }

    @Override
    public int indexOf(Object o) {

        Node<E> current = first;
        for (int i = 0; i < size; i++) {
            if (current.value.equals(o)) {
                return i;
            }
            current = current.next;
        }
        return -1;
    }
    private int size;
    private Node<E> first;

    private static class Node<E> {

        public Node<E> next;
        public E value;
    }
}