0

我有一个带有双值的多维数组，我想对其进行排序..

//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;
            }
        }

该数组具有 [1.5,7.0] [4.2,4.0] 等值...

对于下一部分，我真的不知道它是如何工作的，但是通过阅读这里的其他文章，这是最好的，因为我可以在没有知识的情况下复制

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

以上无法编译（缺少返回语句），这是可以预期的，因为我不知道如何将 Arrays.sort 与比较器一起使用。但我什至不确定我是否在正确的页面上像我一样对 Java（和一般编程）如此陌生。

感谢您的关注！

4

4 回答 4

4

你很接近。您的比较器将取决于您希望结果的顺序。假设您希望按照每行中第一个元素的自然顺序对行进行排序。然后您的代码将如下所示：

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;
        }
    }
};
于 2013-07-08T23:55:32.170 回答
1

我认为@Tap 提供的答案并没有 100% 满足提问者的问题。如前所述，数组仅根据其在第一个索引处的值进行排序。正如预期的那样，排序的结果{{2,0},{1,2},{1,1}}不是{{1,2},{1,1},{2,0}}。{{1,1},{1,2},{2,0}}我已经为实现接口ArrayComparator的所有类型实现了一个泛型，并在我的博客上Comparable发布了它：

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 
    }
}

有了这个ArrayComparator，您可以对多维数组进行排序：

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

Lists数组：

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<>());

(Sorted)Maps并轻松建立：

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());

请记住，泛型类型必须实现Comparable接口。

于 2015-12-30T21:27:54.490 回答
0

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

Arrays.sort(contests, (a, b)->Integer.compare(b[0], a[0]));
于 2019-08-31T16:08:17.283 回答
-2

Arrays.sort() 需要一个单维数组，而在您的情况下，您正在尝试传递一个多维数组。

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

然后你使用 Arrays.sort(d) 因为排序可以在原始类型或包装类型上工作。

于 2013-07-08T22:58:25.607 回答