我使用双链表在java中实现了一个Deque，当我调用迭代器时，我得到一个空指针异常

当我运行这里提供的main（）时，总是会出现这个错误

java.lang.NullPointerException
    at Deque$Node.access$100(Deque.java:98)
    at Deque$DequeIterator.hasNext(Deque.java:83)
    at Deque.main(Deque.java:116)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    at java.lang.reflect.Method.invoke(Method.java:622)
    at edu.rice.cs.drjava.model.compiler.JavacCompiler.runCommand(JavacCompiler.java:272)

为什么迭代器甚至没有为hasNext（）返回任何内容？我可以使用drjava中的interactions面板，并且可以获取迭代器的指针，但是如果我尝试使用与之相关的任何函数，就会得到NullPointerException

import java.util.Iterator;



public class Deque<Item> implements Iterable<Item> {
 private int size;// number of elements
 private Node before;//sentinel marking the beginning of a list
 private Node after;//sentinel marking the end of a list



    public Deque()                           // construct an empty deque
    {
     before= new Node();
     after = new Node();
     before.next=after;
     after.previous=before;
    }

    public boolean isEmpty()                 // is the deque empty?
    {
     return size>0;
    }

    public int size()                        // return the number of items on the deque
    {
     return size;
    }

    public void addFirst(Item item)          // insert the item at the front
    {
     size++;
     Node node = new Node();
     node.item=item;//sets new node equal to the item
     node.previous=before;//sets new node's previous to before which is the beginning sentinel
     node.next=before.next;//sets new node's next to the old first node which was befores next.
     before.next.previous=node;//sets old first item's previous to the new Node making the old first second in the list.
     before.next=node;//sets before's next to the new Node making the new Node first in the list.

    }
    public void addLast(Item item)           // insert the item at the end
    {
     size++;
     Node node = new Node();
     node.item=item;//sets node item to item
     node.next=after;//sets new node's next to after 
     after.previous.next=node;//sets old last node's next to the new node 
     node.previous=after.previous;//sets new node's previous to old last node
     after.previous=node;//now after's previous is the new node making it last in the list.


    }
    public Item removeFirst()                // delete and return the item at the front
    {
     size--;
     Node first= before.next;//gets the first node.
     Node second=first.next;//gets the second element in the list
     second.previous=before;//sets second's previous to before
     before.next=second;//sets before's next to second
     return first.item;


    }

    public Item removeLast()                 // delete and return the item at the end
    {
     size--;
     Node last = after.previous;//sets last node
     Node second2Last= after.previous.previous;//sets second2Last
     second2Last.next=after;//sets second2Last's next to after
     after.previous=second2Last;//sets after's previous to second2last
     return last.item;
    }

    public Iterator<Item> iterator()         // return an iterator over items in order from front to end
    {
     return new DequeIterator();
    }

    private class DequeIterator implements Iterator<Item>{
     Node current=after.next;
     public boolean hasNext(){
      return current.next!=after;

     }
     public void remove(){

     }

     public Item next(){
      Item item=current.item;
      current=current.next;
      return item;   
     }

    }//end class DequeIterator

    private class Node{
     private Item item;
     private Node next;
     private Node previous;

    }

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Deque d = new Deque();

  d.addFirst(1);
  d.addLast(2);
  d.addFirst(3);
  Iterator i = d.iterator();
  System.out.println(i.hasNext());
  while(i.hasNext()){
   System.out.println(i.next());
  }


 }

}

import java.util.Iterator；
公共类Deque实现了Iterable{
私有int size；//元素数
private Node before；//标记列表开头的哨兵
private Node after；//标记列表结尾的哨兵
public Deque（）//构造一个空Deque
{
before=新节点（）；
after=新节点（）；
before.next=之后；
之后。之前=之前；
}
public boolean isEmpty（）//数据是否为空？
{
返回大小>0；
}
public int size（）//返回数据块上的项目数
{
返回大小；
}
public void addFirst（Item）//在前面插入项
{
大小++；
节点=新节点（）；
node.item=item；//将新节点设置为该项
node.previous=before；//将新节点的previous设置为before，它是开始哨兵
node.next=before.next；//将新节点的下一个设置为位于下一个之前的旧第一个节点的下一个。
before.next.previous=node；//将旧的第一项的“上一个”设置为新节点，使旧的第二项在列表中出现。
before.next=node；//将before设置为新节点旁边，使新节点在列表中位于第一位。
}
public void addLast（Item）//在末尾插入项
{
大小++；
节点=新节点（）；
node.item=item；//将节点项设置为item
node.next=after；//将新节点的next设置为after
after.previous.next=node；//在新节点旁边设置旧的最后一个节点
node.previous=after.previous；//将新节点的上一个节点设置为旧的最后一个节点
after.previous=node；//现在after的previous是使其在列表中最后一个的新节点。
}
public Item removeFirst（）//删除并返回前面的项
{
大小--；
Node first=before.next；//获取第一个节点。
Node second=first.next；//获取列表中的第二个元素
second.previous=before；//将second的previous设置为before
before.next=second；//设置before的下一秒
返回第一个项目；
}
public Item removeLast（）//删除并在末尾返回该项
{
大小--；
Node last=after.previous；//设置最后一个节点
Node second2Last=after.previous.previous；//设置second2Last
second2Last.next=after；//将second2Last的next设置为after
after.previous=second2Last；//将after的previous设置为second2Last
返回最后一项；
}
public Iterator Iterator（）//按从头到尾的顺序返回项的迭代器
{
返回新的DequeIterator（）；
}
私有类DequeIterator实现迭代器{
节点电流=after.next；
公共布尔hasNext（）{
返回当前值。下一步！=之后；
}
公共空间删除（）{
}
公共项目下一步（）{
项目=当前项目；
当前=当前。下一步；
退货项目；
}
}//端类deque迭代器
私有类节点{
私人物品；
私有节点下一步；
前一个私有节点；
}
/**
*@param args
*/
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
Deque d=新的Deque（）；
d、 第一（1）；
d、 addLast（2）；
d、 第一（3）；
迭代器i=d.迭代器（）；
System.out.println（i.hasNext（））；
while（i.hasNext（））{
System.out.println（i.next（））；
}
}
}

您的类有以下定义：

private class DequeIterator implements Iterator<Item>{
    Node current=after.next;
    //rest of code
}

私有类DequeIterator实现迭代器{
节点电流=after.next；
//代码的其余部分
}

您正在定义

current

节点是

after

的下一个节点，该节点具有

null

值，并且

after

是双链接列表中的最后一个元素，该元素将为

null

，因此使用

current

执行任何操作都将导致

NullPointerException

---

解决方案：将

current

定义为

before

Deque是一个糟糕的类名，因为它是一个现有接口。@Powerlord这似乎是一些算法或Java编程课程的作业：）。谢谢你，这就是问题所在