java用数组实现一个优先级队列。

好的，下面是用Java数组实现优先级队列的示例代码：

public class PriorityQueue {
    private int[] heap;
    private int maxSize;
    private int size;

    public PriorityQueue(int maxSize) {
        this.maxSize = maxSize;
        heap = new int[maxSize];
        size = 0;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public boolean isFull() {
        return size == maxSize;
    }

    public void enqueue(int item) {
        if (isFull()) {
            throw new RuntimeException("Priority queue is full");
        }
        heap[size] = item;
        heapifyUp(size++);
    }

    public int dequeue() {
        if (isEmpty()) {
            throw new RuntimeException("Priority queue is empty");
        }
        int item = heap[0];
        heap[0] = heap[--size];
        heapifyDown(0);
        return item;
    }

    private void heapifyUp(int index) {
        int parent = (index - 1) / 2;
        while (index > 0 && heap[index] > heap[parent]) {
            swap(index, parent);
            index = parent;
            parent = (index - 1) / 2;
        }
    }

    private void heapifyDown(int index) {
        int left = 2 * index + 1;
        int right = 2 * index + 2;
        int largest = index;
        if (left < size && heap[left] > heap[largest]) {
            largest = left;
        }
        if (right < size && heap[right] > heap[largest]) {
            largest = right;
        }
        if (largest != index) {
            swap(index, largest);
            heapifyDown(largest);
        }
    }

    private void swap(int i, int j) {
        int temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

上述代码定义了一个 `PriorityQueue` 类，它有以下方法：

- `isEmpty()`：判断队列是否为空，返回布尔值。
- `isFull()`：判断队列是否已满，返回布尔值。
- `enqueue(int item)`：将一个元素插入队列中。
- `dequeue()`：从队列中删除元素并返回该元素的值。

在这个示例中，我们使用一个数组来存储队列中的元素。我们使用 `heapifyUp()` 和 `heapifyDown()` 方法来维护堆的性质，确保队列中的元素按照优先级进行排序。在 `enqueue()` 方法中，我们将新元素插入到队列的末尾，然后将它上移以保持堆的性质。在 `dequeue()` 方法中，我们删除队列的根节点（即具有最高优先级的元素），将末尾元素移动到根节点处，然后将其下移以保持堆的性质。

请注意，这个示例中的优先级队列是最大堆，即具有最高优先级的元素总是位于队列的前面。如果您需要实现最小堆，只需要将 `heapifyUp()` 和 `heapifyDown()` 方法中的比较运算符反转即可。