双向链表的java代码实现

public class DoubleLink<T> {

    //头结点
    private DNode<T> mhead;

    //节点个数
    private int mCount;

    //创建一个双向链表类
    private class DNode<T>{
        //前驱节点指针
        public DNode prev;

        //后驱节点指针
        public DNode next;

        //链表值
        public T value;

        //内部类的构造器
        public DNode(DNode prev, DNode next, T value) {
            this.prev = prev;
            this.next = next;
            this.value = value;
        }
    }

    public  DoubleLink(){
        mhead = new DNode<T>(null,null,null);
        mhead.prev = mhead.next = mhead;
        mCount = 0;
    }

    //返回节点个数
    public int size(){
        return mCount;
    }

    //判断链表是否为空
    public boolean isEmpty(){
        return mCount == 0;
    }

    //获取第index位置的节点
    public DNode<T> getNode(int index) throws Exception {
        //判断索引是否合理
        rangeCheck(index);

        DNode<T> node = mhead.next;

        //循环查询
        for(int i=0; i<index; i++){
            node = node.next;
        }
        return node;
    }

    // 判断下标是否合理
    private void rangeCheck(int index) throws Exception {
        //当下标小于0或者大于节点数时，抛出异常
        if(index > mCount){
            throw new Exception("下标越界");
        }
        if(index < 0){
            throw new Exception("小标小于0");
        }
    }

    //获取节点的值
    public T get(int index) throws Exception {
        //判断下标是否合理
        rangeCheck(index);

        return getNode(index).value;
    }

    //获取第一个节点的值
    public T getFirst() throws Exception {
        return getNode(0).value;
    }

    //获取最后节点的值
    public T getLast()throws Exception{
        return getNode(mCount-1).value;
    }

    //插入节点
    public void insert(int index,T t) throws Exception {
        //插入到第一个节点处
        if(index == 0){
            DNode<T> dNode = new DNode<>(mhead,mhead.next,t);
            mhead.next.prev = dNode;
            mhead.next = dNode;
            mCount++;
            return;
        }

        DNode<T> dNode = getNode(index);
        DNode<T> node = new DNode<>(dNode.prev,dNode,t);

        dNode.prev.next = node;
        dNode.prev = node;

        mCount++;
    }


    //将节点插入第一个节点处
    public void insertFirst(T t) throws Exception {
        insert(0,t);
    }

    //将节点插入到最后一个节点
    public void insertLast(T t) {
        DNode<T> node = new DNode<>(mhead.prev,mhead,t);
        mhead.prev.next = node;
        mhead.prev = node;
        mCount++;
    }

    //删除节点
    public void delete(int index) throws Exception {
        DNode node = getNode(index);
        node.prev.next = node.next;
        node.next.prev = node.prev;
        node = null;
        mCount--;
    }

    //删除第一个节点
    public void deleteFirst() throws Exception {
        delete(0);
    }

    //删除最后一个节点
    public void deleteLast() throws Exception {
        delete(--mCount);
    }
}