JAVA实现双向链表

实现了下双向链表参考了LinkedList源码：

package cn;


/**
 * @author admin
 */
public class LinkedList<E> extends MyAbstractList<E> {

    /**
     * 第一个节点
     */
    private Node<E> first;
    /**
     * 最后一个节点
     */
    private Node<E> last;

    /**
     * node节点对象
     * @param <E>
     */
    private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E item, Node<E> next) {
            this.prev = prev;
            this.item = item;
            this.next = next;

        }
    }

    /**
     * 清空链表元素
     */
    @Override
    public void clear() {
        this.size = 0;
        this.first = null;
        this.last = null;
    }

    /**
     * 获取index位置的节点
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }

    /**
     * 修改index位置的节点
     * @param index
     * @param element
     * @return
     */
    @Override
    public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> node = node(index);
        E old = node.item;
        node.item = element;
        return old;
    }

    /**
     * 添加元素到index位置
     * @param index
     * @param element
     */
    @Override
    public void add(int index, E element) {
        checkPositionIndex(index);
        if (index == this.size) {
            linkLast(element);
        } else {
            linkBoefore(element, node(index));
        }

    }

    /**
     * 添加元素
     * @param e
     * @return
     */
    @Override
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    /**
     * 删除元素
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        checkElementIndex(index);
        Node<E> node=node(index);
        Node<E> prev=node.prev;
        Node<E> next=node.next;

        if(null == prev){
            this.first=next;
        }else {
            prev.next=next;
            node.prev=null;
        }

        if(null == next){
            this.last=prev;
        }else {
            next.prev=prev;
            node.next=null;
        }
        this.size--;
        return node.item;
    }

    /**
     * 查找元素
     * @param element
     * @return
     */
    @Override
    public int indexOf(E element) {
        int index = 0;
        if (element == null) {
            for (Node<E> x = this.first; x != null; x = x.next) {
                if (x.item == null) {
                    return index;
                }
                index++;
            }
        } else {
            for (Node<E> x = this.first; x != null; x = x.next) {
                if (element.equals(x.item)) {
                    return index;
                }
                index++;
            }
        }

        return -1;
    }

    @Override
    public String toString() {
        StringBuffer stringBuffer = new StringBuffer("LinkedList{");
        for (Node<E> x = this.first; x != null; x = x.next) {
            System.out.println(x.item);
            stringBuffer.append(x.item + ",");
        }
        return stringBuffer.toString() + "}";
    }

    /**
     * 尾插
     *
     * @param element
     */
    void linkLast(E element) {
        final Node<E> l = this.last;
        final Node<E> newNode = new Node<>(l, element, null);
        this.last = newNode;
        if (l == null) {
            this.first = newNode;
        } else {
            l.next = newNode;
        }
        this.size++;
    }

    /**
     *  头插法
     * @param element
     * @param succ
     */
    void linkBoefore(E element, Node<E> succ) {
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, element, succ);
        succ.prev = newNode;
        if (pred == null) {
            first = newNode;
        } else {
            pred.next = newNode;
        }
        this.size++;
    }

    /**
     * 根据index获取索引
     * @param index
     * @return
     */
    Node<E> node(int index) {
        if (index < (this.size >> 1)) {
            Node<E> x = this.first;
            for (int i = 0; i < index; i++) {
                x = x.next;
            }
            return x;
        } else {
            Node<E> x = this.last;
            for (int i = size - 1; i > index; i--) {
                x = x.prev;
            }
            return x;
        }
    }

    /**
     * 检查元素索引
     * @param index
     */
    private void checkElementIndex(int index) {
        if (!isElementIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    /**
     * 检查位置索引
     * @param index
     */
    private void checkPositionIndex(int index) {
        if (!isPositionIndex(index)) {
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
        }
    }

    private boolean isElementIndex(int index) {
        return index >= 0 && index < this.size;
    }

    private boolean isPositionIndex(int index) {
        return index >= 0 && index <= this.size;
    }

    private String outOfBoundsMsg(int index) {
        return "Index:" + index + "Size:" + this.size;
    }
}