public final  void adjustTop() 
{
    downHeap();
}

Should be called when the Object at top changes values. Still log(n) worst case, but it's at least twice as fast to

{ pq.top().change(); pq.adjustTop(); }

instead of

{ o = pq.pop(); o.change(); pq.push(o); }

 public final  void clear() 
{
    for (int i = 0; i < = size; i++)
      heap[i] = null;
    size = 0;
}

Removes all entries from the PriorityQueue.

 protected final  void initialize(int maxSize) 
{
    size = 0;
    int heapSize;
    if (0 == maxSize)
      // We allocate 1 extra to avoid if statement in top()
      heapSize = 2;
    else
      heapSize = maxSize + 1;
    heap = new Object[heapSize];
    this.maxSize = maxSize;
}

Subclass constructors must call this.

 public boolean insert(Object element) 
{
    return insertWithOverflow(element) != element;
}

Adds element to the PriorityQueue in log(size) time if either the PriorityQueue is not full, or not lessThan(element, top()).

 public Object insertWithOverflow(Object element) 
{
    if (size <  maxSize) {
      put(element);
      return null;
    } else if (size  > 0 && !lessThan(element, heap[1])) {
      Object ret = heap[1];
      heap[1] = element;
      adjustTop();
      return ret;
    } else {
      return element;
    }
}

insertWithOverflow() is the same as insert() except its return value: it returns the object (if any) that was dropped off the heap because it was full. This can be the given parameter (in case it is smaller than the full heap's minimum, and couldn't be added), or another object that was previously the smallest value in the heap and now has been replaced by a larger one, or null if the queue wasn't yet full with maxSize elements.

 abstract protected boolean lessThan(Object a,
    Object b)
Determines the ordering of objects in this priority queue. Subclasses
must define this one method.

 public final Object pop() 
{
    if (size  > 0) {
      Object result = heap[1];			  // save first value
      heap[1] = heap[size];			  // move last to first
      heap[size] = null;			  // permit GC of objects
      size--;
      downHeap();				  // adjust heap
      return result;
    } else
      return null;
}

Removes and returns the least element of the PriorityQueue in log(size) time.

 public final  void put(Object element) 
{
    size++;
    heap[size] = element;
    upHeap();
}

Adds an Object to a PriorityQueue in log(size) time. If one tries to add more objects than maxSize from initialize a RuntimeException (ArrayIndexOutOfBound) is thrown.

 public final int size() 
{
    return size;
}

Returns the number of elements currently stored in the PriorityQueue.

 public final Object top() 
{
    // We don't need to check size here: if maxSize is 0,
    // then heap is length 2 array with both entries null.
    // If size is 0 then heap[1] is already null.
    return heap[1];
}

Returns the least element of the PriorityQueue in constant time.