如何在java中编写带有迭代器和MaxHeapPriorityQueue的next方法

import java.util.Iterator;

public class MaxHeapPriorityQueue<T extends Comparable<T>> implements Iterable<T> {
    private T[] heap;
    private int size;

    public MaxHeapPriorityQueue(int capacity) {
        heap = (T[]) new Comparable[capacity + 1];
        size = 0;
    }

    public void insert(T item) {
        heap[++size] = item;
        swim(size);
    }

    public T deleteMax() {
        T max = heap[1];
        swap(1, size--);
        sink(1);
        heap[size + 1] = null;
        return max;
    }

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

    public int size() {
        return size;
    }

    private void swim(int k) {
        while (k > 1 && less(k / 2, k)) {
            swap(k, k / 2);
            k = k / 2;
        }
    }

    private void sink(int k) {
        while (2 * k <= size) {
            int j = 2 * k;
            if (j < size && less(j, j + 1)) {
                j++;
            }
            if (!less(k, j)) {
                break;
            }
            swap(k, j);
            k = j;
        }
    }

    private boolean less(int i, int j) {
        return heap[i].compareTo(heap[j]) < 0;
    }

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

    @Override
    public Iterator<T> iterator() {
        return new HeapIterator();
    }

    private class HeapIterator implements Iterator<T> {
        private int current = 1;

        @Override
        public boolean hasNext() {
            return current <= size;
        }

        @Override
        public T next() {
            return heap[current++];
        }
    }
}