基于列对2D整数数组进行排序

Question

我有一个2D数组，我想根据第二列进行排序。 第一列应保持与第二列配对。

2D阵列最初如下（2x10矩阵）：

0 10
1 9
2 9
3 9
4 15
5 10
6 4
7 8
8 11
9 12

我希望上面的2D数组像这样排序：

4 15
9 12
8 11
0 10
5 10
1 9
2 9
3 9
7 8
6 4

现在，我尝试调整答案： 将基于一列的二维数组排序到此代码中：

Arrays.sort(theArray, new Comparator<Integer[]>()
{
    @Override
    public int compare(Integer[] int1, Integer[] int2)
    {
        Integer numOfKeys1 = int1[1];
        Integer numOfKeys2 = int2[1];
        return numOfKeys1.compareTo(numOfKeys2);
    }
});

但是，它似乎根本不对数组进行排序。 在调用sort（）函数后打印数组时，数组的初始顺序。

我也尝试从这里调整答案： 在java中排序字符串的2D数组，但我遇到了同样的问题。

在调整这些解决方案时，我是否犯了一些致命错误，或者我的代码是否有效？

另外，我将如何按降序排序此数组？ 我会将compare（）中的return语句替换为此行吗？

return -numOfKeys2.compareTo(numOfKeys1);

任何帮助将不胜感激。 谢谢！

编辑：只需发布我的其余代码，看看问题是否在其他地方。

public void Sort()
{   
    Integer[][] theArray = {{0,10},{1,9},{2,9},{3,9},{4,15},{5,10},{6,4},{7,8},{8,11},{9,12}};;

    dump(theArray);
    Arrays.sort(theArray, new Comparator<Integer[]>()
    {
        @Override
        public int compare(Integer[] int1, Integer[] int2)
        {
            Integer numOfKeys1 = int1[1];
            Integer numOfKeys2 = int2[1];
            return numOfKeys1.compareTo(numOfKeys2);
        }
    });

    System.out.println("====");
    dump(theArray);     
}

public void dump(Integer[][] array)
{
    for(int p = 0, q = 10; p < q; p++)
    {
        System.out.println(array[p][0] + " " + array[p][1]);
    }
}

编辑2：

我有它的工作。 谢谢大家的帮助。 我有多个Sort（）函数（一个不起作用的旧函数，以及你在上面看到的函数），但事实证明我调用了错误函数，即使我认为我改变了调用。 只是其中一天。

如果要对数组进行排序，请随意使用上面的代码。 它现在完全正常工作。

Answer 1

这对我来说可以。 要颠倒顺序，你要否定原始compareTo ， 或交换变量，但不能同时交换两者。

我们可能需要查看剩下的代码才能理解为什么你会看到你所看到的东西; 我逐字地剪切并粘贴了你的代码，所以问题很好，问题出在其他地方。

---

dump(theArray);
Arrays.sort(theArray, new Comparator<Integer[]>() {
    public int compare(Integer[] int1, Integer[] int2) {
        Integer numOfKeys1 = int1[1];
        Integer numOfKeys2 = int2[1];
        return numOfKeys1.compareTo(numOfKeys2);
    }
});
System.out.println("================");
dump(theArray);


0 10 
0 10 
1 9 
2 9 
3 9 
4 15 
5 10 
6 4 
7 8 
8 11 
9 12 
================
6 4 
7 8 
1 9 
2 9 
3 9 
0 10 
0 10 
5 10 
8 11 
9 12 
4 15 

Answer 2

代码也适用于我。 对不起凌乱的代码，我不得不做一个快速测试。 问候！

import java.util.*;

class arraysort {

    public static Integer[][] mysort(Integer[][] ar) {
        Arrays.sort(ar, new Comparator<Integer[]>() {
            @Override
            public int compare(Integer[] int1, Integer[] int2) {
                Integer numOfKeys1 = int1[1];
                Integer numOfKeys2 = int2[1];
                return numOfKeys1.compareTo(numOfKeys2);
            }
        });
        return ar;
    }

    public static void main(String[] s) {
        Integer[][] myarr = {{0, 10}, {1, 9}, {2, 9}, {3, 9}, {4, 15}, {5, 10}, {6, 4}};

        for (Integer[] i : myarr) {
            System.out.println(i[0] + "," + i[1]);
        }

        myarr = mysort(myarr);

        for (Integer[] i : myarr) {
            System.out.println(i[0] + "," + i[1]);
        }
    }
}

Answer 3

我也完全运行你的代码并且它有效...但有一件事我必须更换

System.out.println(array[0][p] + " " + array[1][p]);

同

System.out.println(array[p][0] + " " + array[p][1]);

运行代码，因为否则它会给出数组索引超出范围的异常。

否定compareTo返回比交换值更容易，并且允许轻松更改。