如何在java中按整数值的一列排序多维字符串数组

Question

我有一个多维数组:

String[][] array = new String[10][2];

在第一列中，我的字符串在我的情况下是用户名，但在第二列中，我的字符串应该表示整数。现在我想对数组进行如下排序:

Before:
Petter 543
John   276
Jay    1879
Alf    5021
etc.
After:
Alf    5021
Jay    1879
Petter 543
John   276
etc.

所以我想把最高的值放在顶部，最低的值放在底部，但不要把名字弄乱。到目前为止，我发现的是如何对所有整数多维数组或字符串多维数组进行排序，而不是如何根据整数对第二列进行排序。

我曾经把它排序过，但它是按"字母"排序的:

所以1000是最高分12分是第二高分999999为最低分。

就像1代表"a"，9代表"z"。

Answer 1

使用Java 8流:

String[][] out = Arrays.stream(names)
    .sorted(Comparator.comparing(x -> -Integer.parseInt(x[1])))
    .toArray(String[][]::new);

Answer 2

如果person和id以某种方式相关联，那么最好创建一个对它们建模的类(POJO)，使POJO类具有可比性，定义POJO的列表，并使用Collections#sort根据所需的标准进行排序…

另一件要考虑的事情是，您有一个二维字符串数组字符串[][]但你的问题是

…如何排序多维字符串数组在整数值在java中的一列?

这意味着你需要考虑将字符串解析为整数…(作为一个很好的提示)

public class MyPojo implement Comparator<MyPojo>{
private String name;
private String id;
...implements the method of the comparator 
}

主测试类中的do

List<MyPojo> mList = new ArrayList<MyPojo>();
mList.add(...);
mList.add(...);
mList.add(...);

Collections.sort(mList);
System.out.println(mList)

Answer 3

循环遍历数组，直到它已排序，并在每次未排序时进行交换。

public static void main(String[] args) {
    String[][] array = new String[4][2];
    array[0][0] = "Petter"; array[0][1] = "543";
    array[1][0] = "John";   array[1][1] = "276";
    array[2][0] = "Jay";    array[2][1] = "1879";
    array[3][0] = "Alf";    array[3][1] = "5021";
    System.out.println(Arrays.deepToString(array)); // [[Petter, 543], [John, 276], [Jay, 1879], [Alf, 5021]]
    sortArrayByScore(array);
    System.out.println(Arrays.deepToString(array)); // [[Alf, 5021], [Jay, 1879], [Petter, 543], [John, 276]]
}
public static void sortArrayByScore(String[][] array) {
    String tmpName, tmpScore;
    boolean sorted = false;
    while (!sorted) {
        sorted = true;
        for (int i = 0 ; i < array.length - 1 ; i++) {
            if (Integer.parseInt(array[i][1]) < Integer.parseInt(array[i+1][1])){
                sorted = false;
                // SWAP NAMES
                tmpName = array[i][0];
                array[i][0] = array[i+1][0];
                array[i+1][0] = tmpName;
                // SWAP SCORES
                tmpScore = array[i][1];
                array[i][1] = array[i+1][1];
                array[i+1][1] = tmpScore;
            }
        }
    }
}

Answer 4

我的建议是采用2D数组的第二列，并将其放在自己的整数数组中。然后，调用该数组上的Arrays.sort()。最后，将新排序的数组作为字符串值放回2D数组中。下面是它的样子，

int arr = new int[10];
String[][] copy = new String[10][2];
for(int i = 0; i < array.length; i++){
    arr[i] = Integer.parseInt(array[i][1]);
    System.arraycopy(array[i], 0, copy[i], 0, array[i].length);
}
Arrays.sort(arr);
for(int i = 0; i < array.length; i++){
    array[i][1] = String.valueOf(arr[i]);
}
//fixing the names
for(int i = 0; i < copy.length; i++){
    for(int j = 0; j < array.length; j++){
        if(copy[i][1] == array[j][1]){
             array[j][0] = copy[i][0];
             break;
        }
    }
}

EDIT:为了处理名称的顺序，我更改了代码以包含2D数组的副本，以便在按顺序重写整数值后，检查每个整数的移动位置。对于每个整数，对应的名称被转移到整数移动的位置。

Answer 5

使用比较器对数组中的项进行排序。在你的例子中，你有一个数组的数组，所以你需要一个数组的比较器。您可以使用字符串数组的Comparator，它假定第二项是值。

public class SomeComparator implements Comparator<String[]> {
    /**
     * Assumes each row is length 2 and the 2nd String is really a number.
     */
    @Override
    public int compare(String[] row1, String[] row2) {
        int value1 = Integer.parseInt(row1[1]);
        int value2 = Integer.parseInt(row2[1]);
        // compare value2 first to sort descending (high to low)
        return Integer.compare(value2, value1);
    }
}

然后可以使用数组进行排序。像这样排序

String[][] data = newData(); // or however you get your data
Arrays.sort(data, new SomeComparator());

Answer 6

您可以使用Comparator对第二个元素的Integer值上的内部String[]项进行排序，而不是使用默认的字符串排序:

Arrays.sort(array, (o1, o2) -> Integer.valueOf(o2[1]).compareTo(Integer.valueOf(o1[1])));

在这里，您使用lambda语法来完成与以下操作相同的操作:

Arrays.sort(data, new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return Integer.valueOf(o2[1]).compareTo(Integer.valueOf(o1[1]));
    }
});