Double.compare(a[0],b[0])) 如何工作？

Question

I want to sort the 2D array

int[][] a1 = new int[][2];

and contents are

6, 8
5, 7
1, 3
2, 4

my expected output is:

1, 3
2, 4
5, 7
6, 8

I found that we can use Double.compare() method as,

Arrays.sort(a1,(a,b)->Double.compare(a[0],b[0]));

This did sort the array as I wanted, but I don't know how it is working? can someone explain

Answer 1

Arrays.sort(collection, oracle) is the API you are using here. The collection is a list of (thingies), and the oracle is code (not a value, it's code , or at least, a value pointing at code). The oracle can decide which of 2 things is to be sorted 'before' the other.

Given an oracle that can tell you for any 2 (thingies) which one 'comes before', and a collection of (thingies), you can sort it efficiently. How? Well, various algorithms - point is, Arrays.sort is that algorithm and just like you can drive a car without knowing how a combustion engine works, you can use Arrays.sort without knowing those kinds of details. If you'd like to know - java's libraries are open source, you can have a look.

So, what's happening here?

Your list ( a1 ) is a list of (thingies). (thingies) here is int[] . After all, you have an int[][] , and that is not a '2D int array' (that does not exist in java). It is an array of int arrays. (Which you can trivially use to emulate a 2D int array, so that's nice). So, When you try to pass a variable of type int[][] to Arrays.sort , you've handed an array of int[] (well, an array of them).

Thus, the oracle needs to decide which of 2 int arrays is 'earlier'.

And it does just that: The (a, b) are the 2 int arrays, and the code then decides which of those 2 is 'earlier' by looking at their first value ( a[0] and b[0] ) and then handing them to the Double.compare method which just.. compares 2 doubles the way you'd think (5 is 'before' 8.2, because, well, it is).

Why Double ? No reason, no idea. Integer would make for more efficient and more readable code; all int can be converted to double without loss, so Double.compare(someInt, someOtherInt) always returns the exact same thing as Integer.compare(someInt, someOtherInt) . It's just less readable and less efficient.