Java双链表的实现

public class DoubleLink <T>{
     //表头
     privte DNode<T> mHead;
     //节点个数
     private int mCount;
     //双向链表节点对应的结构体
     private class DNode<T>{
          public DNode prev;
          public DNode next;
          public T value;
          public DNode(T value,DNode prev, DNode next){
              this.value=value;
              this.prev=prev;
              this.next=next;
          }
     }

     //构造函数
     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位置的节点
   privte DNode<T> getNode(int index){
       if(index<=0||index>mCount)
       throw new IndexOutOfBoundsException();
       //正向查找
       if(index<=mCount/2){
           DNode<T> node=mHead.next;
           for(i=0;i<index;i++)  node=node.next;
           return node;
       }
       //反向查找
       DNode<T> rNode=mHead.prev;
       int rIndex=mCount-index-1;
       for(int j=0;j<rIndex;j++) rNode=rMode.prev;
       return rNode;
   }
   //获取第index位置节点的值
   public T getIndex(){
      return getNode(index).value;
   }
   //获取第一个节点的值
   public T getFirst(){
      return getNode(0).value;
   }
  public T getLast(){
      return getNode(mCount-1).value;
  }
  //将节点插入到index位置之前
  public void insert(int index, T t){
      if(mCount==0){
          DNode<T> node=new DNode<T>(t,mHead,mHead.next);
          mHead.next.prev=node;
          mHead.next=node
          mCount++;
          return ;
      }
      DNode<T> iNode=getNode(index);
      DNode<T> tNode=new DNode<T>(t,iNode.prev,iNode);
      iNode.prev.next=tNode;
      iNode.prev=tNode;
      mCount++;
      return;
  }
  //将节点插入到第一个节点
  public void insertFist(T t){
      insert(0,t);
  }
  //将节点插入到最后一个节点
  public void appendLast(T t){
      DNode<T> node=new DNode<T>(t,mHead.prev,mHead);
      mHead.prev.next=node;
      mHead.prev=node;
      mCount++;
  }
  //删除index位置节点
  public void delNode(int index){
      DNode<T> node=getNode(index);
      node.prev.next=node.next;
      node.next.prev=node.prev;
      node=null;
      mCount--;
  }
  //删除第一个节点
  public void deleteFirst(){
    delNode(0);
  }
  //删除最后一个节点
    public void deleteFirst(){
    delNode(mCount-1);
  }
}