LinkedList Implementation in Java Please review my implementation. I know there is already an implementation in Java, but I just wanted to come up with my implementation. Let me know if I can improve this.

import java.util.NoSuchElementException;

public class LinkedListImplementation&lt;T&gt; {
    private int size;
    private ListNode&lt;T&gt; head;

    static class ListNode&lt;T&gt; {
        private T value;
        private ListNode&lt;T&gt; next;

        public ListNode(T val) {
            this.value = val;
            this.next = null;
        }

        public T getValue() {
            return value;
        }

        public ListNode&lt;T&gt; getNext() {
            return next;
        }

        public void setNext(ListNode&lt;T&gt; nextNode) {
            this.next = nextNode;
            return;
        }

        public String toString() {
            if(this.value == null) {
                return "null";
            }
            return this.value.toString();
        }
    }

    public LinkedListImplementation() {
        head = new ListNode(0);
        head.setNext(null);
        size = 0;
    }

    public void add(T val) {
        ListNode&lt;T&gt; cur = new ListNode&lt;&gt;(val);
        if(size == 0) {
            head.setNext(cur);
            size++;
            return;
        }

        ListNode&lt;T&gt; prev = head;
        while(prev.getNext() != null) {
            prev = prev.getNext();
        }

        prev.setNext(cur);
        size++;
        return;
    }

    public boolean remove(T val) {
        if(size == 0) {
            throw new NoSuchElementException();
        }

        ListNode&lt;T&gt; cur = head;
        ListNode&lt;T&gt; prev = null;
        while(cur.getNext() != null &amp;&amp; cur.getNext().getValue() != val) {
            prev = cur;
            cur = cur.getNext();
        }

        if(cur.getNext() != null &amp;&amp; cur.getNext().getValue() == val) {
            prev = cur;
            cur = cur.getNext();
            prev.setNext(cur.getNext());
            size--;
        }
        else {
            return false;
        }
        return true;
    }

    public int size() {
        return size;
    }

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

    public void clear() {
        head.setNext(null);
        size = 0;
        return;
    }

    public ListNode&lt;T&gt; get(int index) {
        if(index &gt;= size) {
            throw new ArrayIndexOutOfBoundsException();
        }

        int curIndex = index;
        ListNode&lt;T&gt; cur = head;

        while(cur.getNext() != null &amp;&amp; curIndex-- &gt; 0) {
            cur = cur.getNext();
        }

        if(curIndex != -1) {
            throw new NoSuchElementException();
        }
        return cur.getNext();
    }

    public String toString() {
        StringBuilder sb = new StringBuilder();
        ListNode&lt;T&gt; cur = head;
        sb.append(cur.getValue() + "-&gt;");

        while(cur.getNext() != null) {
            sb.append(cur.getNext().getValue() + "-&gt;");
            cur = cur.getNext();
        }
        sb.append("null");
        return sb.toString();
    }

    public static void main(String[] args) {
        LinkedListImplementation&lt;Integer&gt; list = new LinkedListImplementation&lt;&gt;();
        System.out.println(list.size());
        list.add(1);
        list.add(3);
        list.add(5);
        System.out.println(list.remove(3));
        System.out.println(list.size());
        System.out.println(list.get(1));
        System.out.println(list.remove(6));
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        //System.out.println(list.get(20));// ArraysIndexOutOfBoundsException.
        System.out.println(list.remove(5));
        System.out.println(list.size());
        //System.out.println(list.get(1));// ArraysIndexOutOfBoundsException.
        System.out.println(list.get(0));
        list.clear();
        System.out.println(list.size());
        //System.out.println(list.remove(1));//NoSuchElementException.
    }
}
The name LinkedListImplementation seems a little awkward, especially if someone else may try to use it.  It's understandable that you want to avoid using the same name as the official class, in which case you can consider MyLinkedList as the class name.
There's no need for that stray return at the end of clear() since it's a void function.
I'm not sure why those statements in main() are commented out.  Testing for exceptions is okay.  But, perhaps this indicates that you should have actual unit testing using JUnit.  main() would then initiate these tests without the need to comment out any of them.