Question

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

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

上面的编译失败（缺少return语句），这是预料之中的，因为我不知道如何将Arrays.sort与比较器一起使用。但我甚至不确定我是否在正确的页面上像我一样对Java（以及一般的编程）不熟悉。

感谢您的期待！

Answer 1

你非常接近。比较器将取决于您希望结果的顺序。假设您希望按照每行中第一个元素的自然顺序对行进行排序。然后你的代码看起来像：

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

我认为@Tap提供的答案并不能满足100％的问题。如上所述，数组仅在第一个索引处对其值进行排序。正如预期的那样，排序{{2,0},{1,2},{1,1}}的结果将是{{1,2},{1,1},{2,0}}而不是{{1,1},{1,2},{2,0}}。我为实现ArrayComparator接口的所有类型实现了通用Comparable并将其释放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 
    }
}

使用此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接口。

Answer 3

使用int [] []的lambda排序数组的解决方案示例：

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

Answer 4

Arrays.sort（）需要一个单维数组，而在你的情况下，你试图传递一个多维数组。

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

然后使用Arrays.sort（d），因为排序可以处理基元类型或包装类型。

Java - 对多维双数组进行排序

4 个答案: