class GFG {
    public static void main(String args[])throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while(t-- > 0) {
            // take array and kth element input
            String n_k[] = br.readLine().split(" ");
            // store array size in n && kth element to find in k
            int n = Integer.parseInt(n_k[0]);
            int k = Integer.parseInt(n_k[1]);
            // Array String input
            String s[] = br.readLine().split(" ");
            int d[] = new int[n];
            for(int i = 0; i < n; i++) {
                d[i] = Integer.parseInt(s[i]);
            }
            PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
            // insert elements into the maxHeap
            for(int i = 0; i < n; i++) {
                maxHeap.add(d[i]);
            }
            
            // pop the top k elements from the maxHeap
            for(int i = 0; i < k; i++) {
                System.out.print(maxHeap.poll() + " ");
            }
            System.out.println();
        } // end of while
    } // end of main
} // end of class

try (Scanner scan = new Scanner(System.in)) {
    int totalCases = scan.nextInt();
    while (totalCases-- > 0) {
        int n = scan.nextInt();
        int k = scan.nextInt();
        Queue<Integer> minHeap = new PriorityQueue<>(k);
        for (int i = 0; i < n; i++) {
            if (minHeap.size() == k)
                minHeap.remove();
            minHeap.add(scan.nextInt());
        }
        System.out.println(minHeap.stream()
                                  .sorted(Comparator.reverseOrder())
                                  .map(String::valueOf)
                                  .collect(Collectors.joining(" ")));
    }
}

只需将您的代码替换为以下内容。
在声明优先级队列时，您可以使用反向顺序提供比较器。
PriorityQueue<Integer> newHeap = new PriorityQueue<>(minHeap.size(), Comparator.reverseOrder());
这里我创建了一个新的 newHeap，它将以反向顺序存储所有现有元素，然后执行所有现有操作。
它会给出预期的答案。
1
5 2
12 5 787 1 23
输出
787 23
这将对您有所帮助。
class GFG {
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int t = Integer.parseInt(br.readLine());
        while (t-- > 0) {
            String n_k[] = br.readLine().split(" ");
            int n = Integer.parseInt(n_k[0]);
            int k = Integer.parseInt(n_k[1]);
            String s[] = br.readLine().split(" ");
            int d[] = new int[n];
            for (int i = 0; i < n; i++) {
                d[i] = Integer.parseInt(s[i]);
            }
            PriorityQueue<Integer> minHeap = new PriorityQueue<>();
            for (int i = 0; i < n; i++) {
                minHeap.add(d[i]);
                // if size of heap increases pop tht last element
                if (minHeap.size() > k) {
                    minHeap.poll();
                }
            }
            PriorityQueue<Integer> newHeap = new PriorityQueue<>(minHeap.size(), Comparator.reverseOrder());
            newHeap.addAll(minHeap);
            while (newHeap.size() > 0) {
                System.out.print(newHeap.peek() + " ");
                newHeap.poll();
            }
            System.out.println();
        }
    }
}