[手写数据结构]单链表

public class MyLinkedList<E>{
    private final Node<E> DUMMY_FRONT = new Node<>(null,null);
    private int size;
    
    public MyLinkedList() {
    }
    //LinkedList存储的元素就是一个个的Node节点对象
    //内存中只需要一个模板，所以定义为static
    private static class Node<E>{
        E item;
        Node next;

        public Node(E item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    /**
     *添加一个元素，默认为从头添加
     * @param e 元素
     */
    public void addFirst(E e){
        DUMMY_FRONT.next = new Node<E>(e,DUMMY_FRONT.next);
        //维护size
        size++;
    }

    /**
     * 默认在链表尾添加
     * @param e
     */
    public void add(E e){
        addLast(e);
    }

    /**
     * 在指定的索引位置添加元素
     * @param index 指定索引位置
     * @param e 元素
     */
    public void add(E e,int index){
        checkAddIndex(index);
        Node<E> addIndex =  DUMMY_FRONT;
        for (int i = 0;i<index;i++)
            addIndex=addIndex.next;
        addIndex.next = new Node<E>(e,addIndex.next);
        size++;
    }

    /**
     * 添加元素在链表尾
     * @param e
     */
    public void addLast(E e){
        add(e,size);
    }

    /**
     * 删除指定索引位置的元素
     * @param index
     * @return
     */
    public E remove(int index){
        checkIndex(index);
        Node<E> removeIndex = DUMMY_FRONT;
        for (int i=0 ; i<index;i++)
            removeIndex=removeIndex.next;
        Node<E> tempNode = removeIndex.next;
        removeIndex.next=tempNode.next;
        tempNode.next=null;
        size--;
        return tempNode.item;
    }

    /**
     * 删除指定元素
     * @param e
     */
    public void remove(E e){
        remove(indexOf(e));
    }

    /**
     * 删除首元素
     * @return
     */
    public E removeFirst(){
       return remove(0);
    }

    /**
     * 删除尾元素
     * @return
     */
    public E removeLast(){
        return remove(size-1);
    }

    /**
     * 修改指定索引位置的元素，返回被修改的元素
     * @param e
     * @param index
     * @return
     */
    public E set(E e,int index){
        checkIndex(index);
        Node<E> setIndex = DUMMY_FRONT.next;
        for (int i = 0; i < index; i++)
            setIndex=setIndex.next;
        E retE = setIndex.item;
        setIndex.item=e;
        return retE;
    }

    /**
     * 查询指定索引位置上的元素
     * @param index
     * @return
     */
    public E get(int index){
        checkIndex(index);
        Node<E> getIndex = DUMMY_FRONT.next;
        for (int i = 0; i<index ; i++)
            getIndex=getIndex.next;
        return getIndex.item;
    }

    /**
     * 返回第一个元素
     * @return
     */
    public E getFirst(){
        return get(0);
    }

    /**
     * 返回最后一个元素
     * @return
     */
    public E getLast(){
        return get(size-1);
    }

    /**
     * 查询是否存在指定元素
     * @param e
     * @return
     */
    public boolean contains(E e){
        return indexOf(e)!=-1;
    }

    /**
     * 查找对应元素的所在索引
     * @param e
     * @return
     */
    public int indexOf(E e) {
        Node<E> node =DUMMY_FRONT.next;
        if (e == null){
            for (int i = 0; i < size;i++ ){
                if (node.item==e)
                    return i;
                node=node.next;
            }
        }else {
            for (int i = 0; i < size;i++ ){
                if (e.equals(node.item))
                    return i;
                node=node.next;
            }
        }
        return -1;
    }

    /**
     * 获取集合是否为空
     * @return
     */
    public boolean isEmpty(){
        return size==0;
    }

    /**
     * 返回size
     * @return
     */
    public int getSize(){
        return size;
    }

    /**
     * 判断修改索引是否有效
     * @param index
     */
    private void checkIndex(int index){
        if (index<0 || index>=size){
            throw new IllegalArgumentException("the index:"+index+" is out of size:"+size);
        }
    }

    /**
     * 判断添加索引是否有效
     * @param index
     */
    private void checkAddIndex(int index) {
        if (index<0 || index>size){
            throw new IllegalArgumentException("the index:"+index+" is out of size:"+size);
        }
    }

    @Override
    public String toString() {
        StringBuilder resStr = new StringBuilder();
        resStr.append("size:"+size+"[");
        Node<E> cur = DUMMY_FRONT.next;
        for (int i = 0; i < size ; i++){
            resStr.append(cur.item);
            if (i != size-1)
                resStr.append("->");

            if (cur.next!=null) {
                cur = cur.next;
            }
        }
        resStr.append("]");
        return resStr.toString();

    }
}