Create maxHeap, difference between Collections.reverseOrder() and ((a, b) -> b - a);

I encountered an edge case in a leetcode problem, where when I use new PriorityQueue<>(Collections.reverseOrder()); it passes, but when I use new PriorityQueue<>((a, b) -> b - a); the solution wasn't accepted.

The leetcode problem is 480. Sliding Window Median https://leetcode.com/problems/sliding-window-median/

Here's the code:

class Solution {
    public double[] medianSlidingWindow(int[] nums, int k) {
        double[] res = new double[nums.length - k + 1];
        PriorityQueue<Integer> left = new PriorityQueue<>(Collections.reverseOrder());
        // This doesn't work:
        //PriorityQueue<Integer> left = new PriorityQueue<>((a, b) -> b - a);
        PriorityQueue<Integer> right = new PriorityQueue<>();

        for (int i = 0; i < nums.length; i++) {
            if (left.size() <= right.size()) {
                right.add(nums[i]);
                left.add(right.remove());
            } else {
                left.add(nums[i]);
                right.add(left.remove());
            }
            if (left.size() + right.size() == k) {
                double median;
                if (left.size() == right.size()) {
                    median = (double)((long)left.peek() + (long)right.peek()) / 2;
                } else {
                    median = (double)left.peek();
                }
                int start = i - k + 1;
                res[start] = median;
                if (!left.remove(nums[start])) {
                    right.remove(nums[start]);
                }
            }
        }
        return res;

    }
}

I thought the different approaches to create maxHeap are the same, I have no idea why it leads to different result since the edge case is tricky.