Java - Sort a multidimensional double array

Question

I have a multidimensional array with double values that I would like to sort..

//declare array    
standingsB = new Double[10][2];

//populate array from the temparray created during read from file
arryLgt = 0;
        for (int row = 0; row < standingsB.length; row++){

            for (int column = 0; column < standingsB[row].length; column++) {


                standingsB[row][column] = Double.parseDouble(tempStandingsArray[arryLgt]);
                arryLgt = arryLgt + 1;
            }
        }

The array has values such as [1.5,7.0] [4.2,4.0] etc...

For the next part I don't really know how it works but from reading other articles here this is the best as I can copy without knowledge

Arrays.sort(standingsB, new Comparator<Double[]>() {
            @Override
            public int compare(Double[] s1, Double[] s2) {
                compare(s1, s2);
            }
        });

The above fails to compile (with missing return statement) which is to be expected as I have no idea on how to use the Arrays.sort with a comparator. But I'm not even sure if I'm on the right page being as new to Java (and programing in general) as I am.

Thanks for looking!

Answer 1

You're pretty close. Your comparator will depend on what order you want your results in. Let's say you want the rows to be sorted in the natural order of the first element in each row. Then your code would look like:

Arrays.sort(standingsB, new Comparator<Double[]>() {
    public int compare(Double[] s1, Double[] s2) {
        if (s1[0] > s2[0])
            return 1;    // tells Arrays.sort() that s1 comes after s2
        else if (s1[0] < s2[0])
            return -1;   // tells Arrays.sort() that s1 comes before s2
        else {
            /*
             * s1 and s2 are equal.  Arrays.sort() is stable,
             * so these two rows will appear in their original order.
             * You could take it a step further in this block by comparing
             * s1[1] and s2[1] in the same manner, but it depends on how
             * you want to sort in that situation.
             */
            return 0;
        }
    }
};

Answer 2

I think the answer provided by @Tap doesn't fulfill the askers question to 100%. As described, the array is sorted for its value at the first index only. The result of sorting {{2,0},{1,2},{1,1}} would be {{1,2},{1,1},{2,0}} not {{1,1},{1,2},{2,0}} , as expected. I've implemented a generic ArrayComparator for all types implementing the Comparable interface and released it on my blog :

public class ArrayComparator<T extends Comparable<T>> implements Comparator<T[]> {
    @Override public int compare(T[] arrayA, T[] arrayB) {
        if(arrayA==arrayB) return 0; int compare;
        for(int index=0;index<arrayA.length;index++)
            if(index<arrayB.length) {
                if((compare=arrayA[index].compareTo(arrayB[index]))!=0)
                    return compare;
            } else return 1; //first array is longer
        if(arrayA.length==arrayB.length)
             return 0; //arrays are equal
        else return -1; //first array is shorter 
    }
}

With this ArrayComparator you can sort multi-dimensional arrays:

String[][] sorted = new String[][]{{"A","B"},{"B","C"},{"A","C"}};
Arrays.sort(sorted, new ArrayComparator<>());

Lists of arrays:

List<String[]> sorted = new ArrayList<>();
sorted.add(new String[]{"A","B"});
sorted.add(new String[]{"B","C"});
sorted.add(new String[]{"A","C"});
sorted.sort(new ArrayComparator<>());

And build up (Sorted)Maps easily:

Map<String[],Object> sorted = new TreeMap<>(new ArrayComparator<>());
sorted.put(new String[]{"A","B"}, new Object());
sorted.put(new String[]{"B","C"}, new Object());
sorted.put(new String[]{"A","C"}, new Object());

Just remember, the generic type must implement the Comparable interface.

Answer 3

带有lambda排序数组的解决方案int [] []竞赛示例：

Arrays.sort(contests, (a, b)->Integer.compare(b[0], a[0]));

Answer 4

Arrays.sort() expects a single dimensional array while in your case you are trying to pass a multidimensional array.

eg Double[] d = {1.0,5.2,3.2};

Then you use Arrays.sort(d) since the sort can work on the primitive types or the wrapper types.