If the comparator uses some other variables, when is the variable consumed by the comparator?

I have a code sample below, basically, I want to get the index of the array whose value is from low to high in the input

It works as expected but when I start to add some logic to change the value of input, the poll() method not always returns me the right index.

But I have no idea how this happens

    public static void main(String[] args) {
        Solution s = new Solution();
        int[][] input = new int[][]{
                {8,6,8,1,4,1},
                {10,3,1,8,9,10},
                {1,5,6,9,8,5},
                {10,4,6,7,3,3},
                {6,6,9,1,3,3},
                {3,1,10,3,4,1},
                {6,1,6,10,7,10}
        };
        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(o -> input[o[0]][o[1]]));
        for(int i = 0; i < input.length; i++) {
            for (int j = 0; j < input[0].length; j++) {
                pq.add(new int[]{i, j});
            }
        }
        while(!pq.isEmpty()) {
            int[] h = pq.poll();
            // if I add something to change the input, the poll() method not always returns the index of min val, why?
            System.out.println(h[0] + "  " + h[1] + "  " + input[h[0]][h[1]]);
        }
    }

The comparator is called after you add and after you remove from a PriorityQueue. Comparisons are made to sort the min-heap that backs the queue.

More specifically, PriorityQueue#siftUp is called when after you add, and PriorityQueue#siftDown is called when you remove, but only after the 0-th element of the queue is removed. Both of these methods use the comparator.

Consider this simple example:

public static void main(String[] args) {
  
  int[] a = {1};
  int[] b = {2};
  int[] c = {3};
  int[] d = {4};

  int[][] input = new int[][] {a,b,c,d};
  PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));

  pq.addAll(Arrays.asList(input));

  d[0] = -1;

  while (!pq.isEmpty()) {
    int[] h = pq.poll();
    System.out.println(Arrays.toString(h));
  }
}

Initially when a,b,c,d are added, the queue is partially ordered from the sift up operations so that at least the head of the queue is guaranteed to be {1}. Then element d is mutated to be -1.

It goes without saying that the comparator is not called during the mutation.

Inside the loop, when you call the poll for the first time, you remove the head element, a = 1, and the queue is re-sorted after the head of the heap is removed, using the comparator.

The next element to be removed is d = -1. Hence the print order of removals in my simplified example is 1,-1,2,3, which demonstrates that the comparator is called after you add to the queue and after you remove from the queue, and that is all.

I place the emphasis on the word after because if it were called before you removed from the queue, we would have gotten a different result in the above example (-1,1,2,3 instead of 1,-1,2,3)

It probably also goes without saying that the example I'm giving here is a good reason why you should not mutate the elements in a PriorityQueue after they've been added.

To sum up, you are basically creating a sorted queue of 'addresses' (tuples) pointing to mutable ints.

One 'address' (tuple) will be inserted during queue methods but not afterwards.
If you change the referenced ints, nothing is telling the sorted collection to re-sort. You are effectively corrupting the collection, because the internals of the priority queue will get confused as it would normally expect its state to be sorted in order to insert in proper spot.

The PQ uses 'siftup/siftdown' which basically bubbles up or down the item. If the queue is no longer sorted because of backdoor mutations, this sifting will prematurely end and leave the collection corrupted.