空指針運行時異常

Question

不能似乎發現問題，現在我的代碼中有點丟失...可以真正使用更好的眼睛。真的很感激它。

以下是錯誤：

Exception in thread "main" java.lang.NullPointerException 
    at Heap.<init>(Heap.java:16) 
    at Heap$1.<init>(Heap.java:131) 
    at Heap.main(Heap.java:131) 

http://codepaste.net/jogkx2

public abstract class Heap { 

    private List heap_array; // Arraylist containing heap. 
    private List<ELEM> priority_queue; //ArrayList containing ELEMS. 
    private int heapsize; // Maximum heapsize of the heap. 
    private int n; // Number of elements currently in the heap. 
    private int last_elem = heap_array.size()-1; // last elem in the heap 


    public Heap(int s, int n) { 
     heap_array = new ArrayList(); 
      priority_queue = new ArrayList<ELEM>(); 
      s = heapsize; 
      n = this.n; 
    } 

    protected int returnMaxPriority(){ 
     int max = priority_queue.get(priority_queue.size()-1).getLocation(); 
     return max; 
     } 

    public void shiftDown(int i) { 
     int leftChild = leftChild(i); 
     int rightChild = rightChild(i); 
     int largest = i; 

      // Max Heapify 
     if (leftChild < heap_array.size() 
      && !aboveOrEqual(largest, leftChild)) { 
      largest = leftChild; 
     } 
     if (rightChild < heap_array.size() 
      && !aboveOrEqual(largest, rightChild)) { 
      largest = rightChild; 
     } 

     if (largest != i) { 
      switchElems(largest, i); 
      shiftDown(largest); 
     } 
    } 

    public void insert(Object obj, int priority) { 
       heap_array.add(obj); 
       int object_i = 0; 
      while (object_i > 0 && !aboveOrEqual(parent(object_i), object_i)) { 
      switchElems(parent(object_i), object_i); 
      object_i = parent(object_i); 
      } 
      // enqueue(object_i, priority); 
    } 

    public Object removeLast() { 
     if (heap_array.size() > 0) { 
      switchElems(0, last_elem); 
      Object result = heap_array.remove(last_elem); 
       shiftDown(0); 
      return result; 
     } else { 
      return null; 
     } 
    } 


    public Object get(int index) { 
     return heap_array.get(index); //Return object 
    } 

    public int heapsize() { 
     return heap_array.size(); 
    } 

    protected int parent(int i) { 
     return (i - 1)/2; 
    } 
    protected void update_N(int n){ 
      n = this.n; 
    } 

     protected void update_Size(int size){ 
      heapsize = size; 
    } 

    protected int leftChild(int i) { 
     return 2 * i + 1; 
    } 

    protected int rightChild(int i) { 
     return 2 * i + 2; 
    } 

    protected void switchElems(int i, int j) { 
     Object tmp = heap_array.get(i); 
     heap_array.set(i, heap_array.get(j)); 
     heap_array.set(j, tmp); 
    } 


    public void enqueue(int object_i, int priority) { 
      ELEM tmp = new ELEM(priority, object_i); 
      priority_queue.add(object_i, tmp); 
     } 


    public int dequeue() { 
    if (heap_array.size() > 0) { 
    int max_location = returnMaxPriority(); 
     heap_array.remove(max_location); 
     return max_location; 
     } 
     else{return -1;} 
    } 

    public void changeWeight(int object_i, int priority){ 
      ELEM tmp = new ELEM(priority, object_i); 
      priority_queue.set(object_i, tmp); 
    } 

    protected abstract boolean aboveOrEqual(int value1, int value2); 

    public static void main(String[] args){ 
     Heap h = new Heap(100, 20) { 
      protected boolean aboveOrEqual(int value1, int value2) { 
       return ((Integer)get(value1)).intValue() 
        >= ((Integer)get(value2)).intValue(); //Compares the objects int values. 
      } 
     }; 

     System.out.println("Enter a list of numbers, then type quit: "); 


      for (int i = 0; i < 100; i++) { 
      h.insert(new Integer((int)(100 * Math.random())), i); 
     } 
    } 
} 

---

class sortPriorityArray implements Comparator<ELEM> { 
    @Override 
    public int compare(ELEM s1, ELEM s2){ 
     int value1 = s1.getPriority(); 
     int value2 = s2.getPriority(); 

     if(value1 < value2){ 
     return 1; 
     } 
     else if(value2 > value1){ 
     return -1;  
     } 
     return 0; 
    } 

如果您還可以看看我的插入功能和returnmax。 ELEM類包含優先級和位置，所以我可以按照優先級對priority_queue進行排序，然後以最高優先級先出列，從而以正確的順序出列。

Answer 1

private int last_elem = heap_array.size()-1; // last elem in the heap 

該行在尚未初始化的列表上調用size()。

Answer 2

n = this.n;可能是罪魁禍首。在初始化之前，您正在嘗試引用this.n。除非您正在初始化（不引用）this的成員，否則您將不想在構造函數中使用this。

編輯：我想你的意思是this.n = n;？剛剛看到您的評論，我想這可以解釋它。 :)

Answer 3

異常正在這裏

private int last_elem = heap_array.size()-1; // last elem in the heap 

此時heap_array拋出尚未初始化，所以它是null。最簡單的辦法就是這個移動到構造函數或將其設置爲

private int last_elem = -1; // last elem in the heap 

，因爲這將做同樣的事情。

順便說一句如果您想知道如何爲自己解決這個問題，那麼您可以在調試器中單步執行代碼，它就是IDE中運行旁邊的按鈕。